{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "9bb98532-4bd6-4a6d-80ad-6c3515077805",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "# <center>Python程序设计基础<center>\n",
    "## <center>第八章 类和对象<center>\n",
    " <center>沈万福<center>\n",
    " <center> 办公地点：第十教学楼414室<center>\n",
    " <center>tel:18822265292<center>\n",
    " <center>mail:wfshen@tju.edu.cn<center>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "832f2a79-167c-483c-8b5d-3eee86c9b1bc",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "skip"
    },
    "tags": []
   },
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6fc38cef-acd4-4d76-8d81-324b642c9295",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "## 类和对象\n",
    "**面向对象编程**：把一组数据和处理数据的方法组成**对象**，把行为相同的对象归纳为**类**，通过**封装**隐藏对象的内部细节，通过**继承**实现类的特化和泛化，通过**多态**实现基于对象类型的动态分派。\n",
    "\n",
    "> **封装**（encapsulation）、**继承**（inheritance）、**多态**（polymorphism）是面向对象编程的三大支柱。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "665c0485-6c32-4c38-a3c0-948235e01529",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "在面向对象编程中，**类是一个抽象的概念，对象是一个具体的概念**。我们把同一类对象的共同特征抽取出来就是一个类，比如我们经常说的人类，这是一个抽象概念，而我们每个人就是人类的这个抽象概念下的实实在在的存在，也就是一个对象。简而言之，**类是对象的蓝图和模板，对象是类的实例，是可以接受消息的实体**。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "921809f3-b733-402a-8038-681de4fce6a5",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "在面向对象编程的世界中，**一切皆为对象**，**对象都有属性和行为**，**每个对象都是独一无二的**，而且**对象一定属于某个类**。对象的属性是对象的静态特征，对象的行为是对象的动态特征。按照上面的说法，如果我们把拥有共同特征的对象的属性和行为都抽取出来，就可以定义出一个类。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51cdb954-44d0-4304-9439-81e731373782",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "skip"
    },
    "tags": []
   },
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5aa4e27-915a-4a97-83c5-5181a905f458",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "### 类 (Class)\n",
    "- 类是对象的蓝图：使用`class`关键字加上类名来定义类，通过缩进我们可以确定类的代码块，就如同定义函数那样。    \n",
    "- 类具有属性：属性可以是数据或函数。其中有一些特殊属性，它们以双下划线（```__```）开头，例如，```__doc__```我们该类的文档字符串（\n",
    ">  注意：定义一个类之后，第一个字符串称为docstring，并具有有关该类的简短说明。尽管不是强制性的，但是建议这样做。）\n",
    "- 一旦定义了一个类，就会创建一个具有相同名称的新类对象；\n",
    "- 类具有方法：写在类里面的函数我们通常称之为**方法**，方法就是对象的行为，也就是对象可以接收的消息。方法的第一个参数通常都是`self`，它代表了接收这个消息的对象本身。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "71ef8f70-d0d0-4fbe-9156-ec7443940514",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "<function MyClass.func at 0x0000021C97615E10>\n",
      "这是我的第一个类\n"
     ]
    }
   ],
   "source": [
    "class MyClass:\n",
    "\t\"这是我的第一个类\"\n",
    "\ta = 10\n",
    "\tdef func(self):\n",
    "\t\tprint('Hello')\n",
    "\n",
    "\n",
    "print(MyClass.a)\n",
    "print(MyClass.func)\n",
    "print(MyClass.__doc__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "31d920c2-527a-4cfd-a443-c16a2fc61593",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "class Student: #定义类\n",
    "\n",
    "    def study(self, course_name): #定义类的方法， self一定不能省略\n",
    "        print(f'学生正在学习{course_name}.')\n",
    "\n",
    "    def play(self):\n",
    "        print(f'学生正在玩游戏.')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f0fa366-e30a-44ec-9e43-7d528a1fe335",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "skip"
    },
    "tags": []
   },
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da3c65c0-3d21-425d-818d-35b25524d892",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "### 对象 (Object)\n",
    "- 对象（实例）是类的示例。\n",
    "- 在我们定义好一个类之后，可以使用构造器语法来创建对象： **构造器语法**：类的名字后跟上圆括号；\n",
    "- 创建对象的过程类似于函数调用。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "ea0fb938-8f6c-4e3d-8552-d22949b5aecc",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.Student object at 0x0000021C960D3160>\n",
      "<__main__.Student object at 0x0000021C96025450>\n",
      "0x21c960d3160 0x21c96025450\n"
     ]
    }
   ],
   "source": [
    "stu1 = Student()\n",
    "stu2 = Student()\n",
    "print(stu1)    # <__main__.Student object at 0x10ad5ac50>\n",
    "print(stu2)    # <__main__.Student object at 0x10ad5acd0> \n",
    "print(hex(id(stu1)), hex(id(stu2)))    # 0x10ad5ac50 0x10ad5acd0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7761115-988c-454b-9773-3df6a0aff091",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "notes"
    },
    "tags": []
   },
   "source": [
    "在类的名字后跟上圆括号就是所谓的构造器语法，上面的代码创建了两个学生对象，一个赋值给变量`stu1`，一个复制给变量`stu2`。当我们用`print`函数打印`stu1`和`stu2`两个变量时，我们会看到输出了对象在内存中的地址（十六进制形式），跟我们用`id`函数查看对象标识获得的值是相同的。现在我们可以告诉大家，我们定义的变量其实保存的是一个对象在内存中的逻辑地址（位置），通过这个逻辑地址，我们就可以在内存中找到这个对象。所以`stu3 = stu2`这样的赋值语句并没有创建新的对象，只是用一个新的变量保存了已有对象的地址。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27876491-0fd3-497d-92e9-28dc7d8e87c1",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "刚才的`Student`类中我们定义了`study`和`play`两个方法，两个方法的第一个参数`self`代表了接收消息的学生对象，`study`方法的第二个参数是学习的课程名称。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "a9860ba5-f8b3-44ed-8221-00c7de228930",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "学生正在学习Python程序设计.\n",
      "学生正在学习Python程序设计.\n",
      "学生正在玩游戏.\n",
      "学生正在玩游戏.\n"
     ]
    }
   ],
   "source": [
    "# 通过“类.方法”调用方法，第一个参数是接收消息的对象，第二个参数是学习的课程名称\n",
    "Student.study(stu1, 'Python程序设计')    # 学生正在学习Python程序设计.\n",
    "# 通过“对象.方法”调用方法，点前面的对象就是接收消息的对象，只需要传入第二个参数\n",
    "stu1.study('Python程序设计')             # 学生正在学习Python程序设计.\n",
    "\n",
    "Student.play(stu2)    # 学生正在玩游戏.\n",
    "stu2.play()  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a230024-3d9a-4eb8-8250-7d35f78b395d",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "skip"
    },
    "tags": []
   },
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "edc59627-b384-4d29-8847-1c33316f39de",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "### 方法\n",
    "- 是在类主体内定义的函数。它们用于定义对象的行为\n",
    "- `__init__`方法（初始化方法）：完成对内存的初始化操作，利用`__init__`方法的方式为对象指定属性。\n",
    "\n",
    "我们对上面的`Student`类稍作修改，给学生对象添加`name`（姓名）和`age`（年龄）两个属性。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "390a950e-cae2-419c-8324-b5cee4b56c3d",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "class Student:\n",
    "    \"\"\"学生\"\"\"\n",
    "\n",
    "    def __init__(self, name, age):\n",
    "        \"\"\"初始化方法\"\"\"\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "\n",
    "    def study(self, course_name):\n",
    "        \"\"\"学习\"\"\"\n",
    "        print(f'{self.name}正在学习{course_name}.')\n",
    "\n",
    "    def play(self):\n",
    "        \"\"\"玩耍\"\"\"\n",
    "        print(f'{self.name}正在玩游戏.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "f96e2853-f2a7-48bf-91c9-0102242e5858",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "骆昊正在学习Python程序设计.\n",
      "王大锤正在玩游戏.\n"
     ]
    }
   ],
   "source": [
    "stu1 = Student('骆昊', 40)\n",
    "stu2 = Student('王大锤', 15)\n",
    "stu1.study('Python程序设计')      # 骆昊正在学习Python程序设计.\n",
    "stu2.play()  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c9ed032-492a-43f9-a713-5015b69c4559",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "skip"
    },
    "tags": []
   },
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c68b5217-41c2-41f6-9805-2187d728fcac",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "### 继承性\n",
    "- 继承是一种创建新类的方法，用于在不修改现有类的细节的情况下使用它。新形成的类是一个派生类(或子类)。类似地，现有类是基类(或父类)。主体\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "4be69043-ec3a-4e3e-8837-83f831450f1e",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "鸟准备好了\n",
      "企鹅准备好了\n",
      "企鹅\n",
      "游得更快\n",
      "跑得更快\n"
     ]
    }
   ],
   "source": [
    "# 父类\n",
    "class Bird:\n",
    "    \n",
    "    def __init__(self):\n",
    "        print(\"鸟准备好了\")\n",
    "\n",
    "    def whoisThis(self):\n",
    "        print(\"鸟\")\n",
    "\n",
    "    def swim(self):\n",
    "        print(\"游得更快\")\n",
    "\n",
    "# 子类\n",
    "class Penguin(Bird):\n",
    "\n",
    "    def __init__(self):\n",
    "        # call super() function\n",
    "        super().__init__()\n",
    "        print(\"企鹅准备好了\")\n",
    "\n",
    "    def whoisThis(self): #修改了父类的行为\n",
    "        print(\"企鹅\")\n",
    "\n",
    "    def run(self):   # 创建新run()方法来扩展父类的功能\n",
    "        print(\"跑得更快\")\n",
    "\n",
    "peggy = Penguin()\n",
    "peggy.whoisThis()\n",
    "peggy.swim()\n",
    "peggy.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d15052e1-6173-4319-84cc-b69df7d57834",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "skip"
    },
    "tags": []
   },
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b773e191-504b-441b-be4a-14d1b71e196e",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "### 方法重写小经验：\n",
    "\n",
    "- 当在父类和子类中都定义了```__init __()```方法。 发生这种情况时，派生类中的方法将覆盖基类中的方法。\n",
    "- 当覆盖基本方法时，我们倾向于扩展定义而不是简单地替换它。 通过从派生类中的基类中调用基类中的方法（从Triangle中的```__init __```()中调用```父类名 .__ init __()```来完成相同的操作，或者更好选择```super()```内置函数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "687c51ab-3509-44c3-adb0-a19d6464c463",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "输入边长 1 :  4\n",
      "输入边长 2 :  5\n",
      "输入边长 3 :  6\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "三角形的面积是 9.92\n"
     ]
    }
   ],
   "source": [
    "class Polygon: #父类\n",
    "    def __init__(self, no_of_sides):\n",
    "        self.n = no_of_sides\n",
    "        self.sides = [0 for i in range(no_of_sides)]\n",
    "\n",
    "    def inputSides(self):\n",
    "        self.sides = [float(input(\"输入边长 \"+str(i+1)+\" : \")) for i in range(self.n)]\n",
    "\n",
    "    def dispSides(self):\n",
    "        for i in range(self.n):\n",
    "            print(\"边长\",i+1,\"是\",self.sides[i])\n",
    "\n",
    "\n",
    "class Triangle(Polygon): #子类\n",
    "    def __init__(self):\n",
    "        Polygon.__init__(self,3) # 等效于super().__int__(3)\n",
    "\n",
    "    def findArea(self):\n",
    "        a, b, c = self.sides\n",
    "        # 计算半周长\n",
    "        s = (a + b + c) / 2\n",
    "        area = (s*(s-a)*(s-b)*(s-c)) ** 0.5\n",
    "        print('三角形的面积是 %0.2f' %area)\n",
    "\n",
    "t = Triangle()\n",
    "t.inputSides()\n",
    "t.findArea()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c05d36ad-d13d-4582-857c-470e5959d6b5",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3451727-5851-456a-8d55-690a52c6a8cd",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "### 继承查询：issubclass\n",
    "- 如果对象是该类或从其派生的其他类的示例，则函数isinstance()返回True。Python中的每个类都继承自基类object。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "2d456dff-8f0e-459a-8284-0e36e68a477c",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> isinstance(t,Triangle)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "774d1720-2d6c-421c-acb4-aa53e2babc43",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> isinstance(t,int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "4524b336-d77b-4136-aeee-b06a4919e591",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> isinstance(t,object)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "495fbe08-8400-4810-8361-4a1048254c10",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae3d2b44-9a69-4a2d-960a-2b00744f2d6a",
   "metadata": {
    "editable": true,
    "raw_mimetype": "",
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "### 多重继承\n",
    "\n",
    "- 像C ++一样，一个类可以从Python中的多个基类派生。这称为多重继承。\n",
    "- 多重继承中，所有基类的功能都继承到派生类中。多重继承的语法类似于单一继承"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "45a1b200-669c-4135-953e-233c5dd20113",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "class Base1:\n",
    "    pass\n",
    "\n",
    "class Base2:\n",
    "    pass\n",
    "\n",
    "class MultiDerived(Base1, Base2):\n",
    "    pass"
   ]
  },
  {
   "attachments": {
    "f21b5bb4-876b-44b0-b9ec-d9e593c07b13.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "ba30bfda-3e41-4601-bef9-60a64a106cc8",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "![image.png](attachment:f21b5bb4-876b-44b0-b9ec-d9e593c07b13.png)\n",
    "\n",
    "MultiDerived类从Base1和Base2继承"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99502d04-3657-432e-8e60-09de4b553b83",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "skip"
    },
    "tags": []
   },
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb4bfaf8-4966-481f-b281-eb027aca722d",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "### 多级继承\n",
    "- 继承派生类。这称为多级继承。\n",
    "- 基类和派生类的功能被继承到新的派生类中。\n",
    "- 在Python中可以是任何深度。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "925d1938-1e77-4a7e-8a5c-6a34ef9f55aa",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "class Base:\n",
    "    pass\n",
    "\n",
    "class Derived1(Base):\n",
    "    pass\n",
    "\n",
    "class Derived2(Derived1):\n",
    "    pass"
   ]
  },
  {
   "attachments": {
    "7cccd839-7182-40be-805c-706398e942ae.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "e4fddb38-4594-4f19-ac15-7d221ab16cfe",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "![image.png](attachment:7cccd839-7182-40be-805c-706398e942ae.png)\n",
    "\n",
    "Derived1从Base派生，Derived2从Derived1派生。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7bf94818-d447-4c35-aa59-ad8b52555639",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c7e3a73-83b6-4cd2-8af0-742c96cdf8cf",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "### 继承中方法解析顺序(MRO)\n",
    "- Python中的每个类都派生自该类object。它是Python中最基本的类型。从技术上讲，所有其他类（内置的或用户定义的）都是派生类，而所有对象都是object类的示例。\n",
    "\n",
    "- 多继承方案中，将在当前类中首先搜索任何指定的属性。如果未找到，则搜索将以深度优先，从左到右的方式继续进入父类，而无需两次搜索相同的类。\n",
    "\n",
    "- 线性化\n",
    "\n",
    "- 利用```__mro__```属性或者```mro()```方法实现多重继承的可视化\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "ed63cf4c-e359-49d5-bcfd-b04f3d3e75bf",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(__main__.MultiDerived, __main__.Base1, __main__.Base2, object)"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> MultiDerived.__mro__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "3fc12e4b-72db-4c2c-b5d8-8b59eced114d",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[__main__.MultiDerived, __main__.Base1, __main__.Base2, object]"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MultiDerived.mro()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95328f4b-9d14-44de-b06c-8fb86d2bb42c",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "skip"
    },
    "tags": []
   },
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "e94eaa6e-19ce-4d3e-b88b-0810cbe2aa2a",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    ">>> O = object\n",
    ">>> class F(O): pass\n",
    ">>> class E(O): pass\n",
    ">>> class D(O): pass\n",
    ">>> class C(D,F): pass\n",
    ">>> class B(D,E): pass\n",
    ">>> class A(B,C): pass\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "1b2dcec0-0c29-4d78-b401-a8c45004349d",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[__main__.A,\n",
       " __main__.B,\n",
       " __main__.C,\n",
       " __main__.D,\n",
       " __main__.E,\n",
       " __main__.F,\n",
       " object]"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.mro()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "0f89b8ce-db5d-4a8d-abd5-2e6249dabf57",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[<class '__main__.M'>, <class '__main__.B'>, <class '__main__.A'>, <class '__main__.X'>, <class '__main__.Y'>, <class '__main__.Z'>, <class 'object'>]\n"
     ]
    }
   ],
   "source": [
    "class X: pass\n",
    "class Y: pass\n",
    "class Z: pass\n",
    "\n",
    "class A(X,Y): pass\n",
    "class B(Y,Z): pass\n",
    "\n",
    "class M(B,A,Z): pass\n",
    "\n",
    "print(M.mro())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1bd18cd6-b29e-419a-9d0b-01a6a815b619",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "skip"
    },
    "tags": []
   },
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad54d923-742b-4be4-830b-7ef234bbe155",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "## 可封装性\n",
    "\n",
    "- 在Python中，我们可以限制对方法和变量的访问。这样可以防止数据直接修改（称为封装）。在Python中，我们使用下划线作为前缀来表示私有属性，即单“ _”或双“ __”"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "255c6e89-56ad-4d68-b7cd-e776d8666556",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "售价: 900\n",
      "售价: 900\n",
      "售价: 1000\n"
     ]
    }
   ],
   "source": [
    "class Computer:\n",
    "\n",
    "    def __init__(self):\n",
    "        self.__maxprice = 900\n",
    "\n",
    "    def sell(self):\n",
    "        print(\"售价: {}\".format(self.__maxprice))\n",
    "\n",
    "    def setMaxPrice(self, price):\n",
    "        self.__maxprice = price\n",
    "\n",
    "c = Computer()\n",
    "c.sell()\n",
    "\n",
    "# 改变价格\n",
    "c.__maxprice = 1000\n",
    "c.sell()\n",
    "\n",
    "# 使用setter函数\n",
    "c.setMaxPrice(1000)\n",
    "c.sell()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7de08254-86c2-4c30-bb18-6574611270e8",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d842182-3b43-4c48-83e5-e25a827c564d",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "## 多态性\n",
    "\n",
    "- 多态性是一种功能（在OOP中），可以将公共接口用于多种形式（数据类型）。\n",
    "\n",
    "假设我们需要给一个形状上色，有多个形状选项（矩形，正方形，圆形）。但是，我们可以使用相同的方法为任何形状着色。这个概念称为多态。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "2af9a3d1-0443-437f-a3f0-f468174fdb80",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "鹦鹉会飞\n",
      "企鹅不会飞\n"
     ]
    }
   ],
   "source": [
    "class Parrot:\n",
    "\n",
    "    def fly(self):\n",
    "        print(\"鹦鹉会飞\")\n",
    "    \n",
    "    def swim(self):\n",
    "        print(\"鹦鹉不会游泳\")\n",
    "\n",
    "class Penguin:\n",
    "\n",
    "    def fly(self):\n",
    "        print(\"企鹅不会飞\")\n",
    "    \n",
    "    def swim(self):\n",
    "        print(\"企鹅会游泳\")\n",
    "\n",
    "# 通用接口\n",
    "def flying_test(bird):\n",
    "    bird.fly()\n",
    "\n",
    "#示例化对象\n",
    "blu = Parrot()\n",
    "peggy = Penguin()\n",
    "\n",
    "# 传递对象\n",
    "flying_test(blu)\n",
    "flying_test(peggy)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c138b31-4ecf-46f5-8c61-afb75cc761ce",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "skip"
    },
    "tags": []
   },
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5995a04-3b89-40b8-bb56-af880de387c6",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "## 运算符的重载\n",
    "\n",
    "**运算符重载**：同一运算符根据上下文具有不同的含义。如+运算符，将对两个数字执行算术加法、合并两个列表并连接两个字符串。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "31a11381-5bb5-44df-81ba-02700bec9a57",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'Point' and 'Point'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m----------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m    Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[79], line 8\u001b[0m\n\u001b[0;32m      6\u001b[0m p1 \u001b[38;5;241m=\u001b[39m Point(\u001b[38;5;241m2\u001b[39m,\u001b[38;5;241m3\u001b[39m)\n\u001b[0;32m      7\u001b[0m p2 \u001b[38;5;241m=\u001b[39m Point (\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m,\u001b[38;5;241m2\u001b[39m)\n\u001b[1;32m----> 8\u001b[0m \u001b[43mp1\u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43mp2\u001b[49m\n",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'Point' and 'Point'"
     ]
    }
   ],
   "source": [
    "class Point:\n",
    "    def __init__(self, x = 0, y = 0):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "\n",
    "p1 = Point(2,3)\n",
    "p2 = Point (-1,2)\n",
    "p1+p2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e2e2216-40a2-472a-a23a-03fa977d81bd",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "**魔术方法**：由类中的以双下划线开头的特殊函数定义。区别于普通的函数。如初始化方法的```__init__()```就是其中之一。使用特殊函数，我们可以使我们的类与内置函数兼容。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "59ca59cd-3981-47aa-b873-99ea69e634f2",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.Point object at 0x0000021C96285360>\n"
     ]
    }
   ],
   "source": [
    ">>> p1 = Point(2,3)\n",
    ">>> print(p1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ad05fcb-c480-458c-91a4-f09f06936780",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "class Point:\n",
    "    def __init__(self, x = 0, y = 0):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "    \n",
    "    def __str__(self):\n",
    "        return \"({0},{1})\".format(self.x,self.y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9bcb9bfc-7bf0-453f-aaff-90b461f77ce6",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "再次尝试print()函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "61476baf-5250-48a9-a6b7-922043caa69b",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2,3)\n",
      "(2,3)\n"
     ]
    }
   ],
   "source": [
    ">>> p1 = Point(2,3)\n",
    ">>> print(p1)\n",
    ">>> print('(2,3)')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afa5f218-0ce0-4209-a2b1-3c1a4588d4bd",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "上例说明："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "f7e541b3-e898-45e5-b9fa-0e7309004f0d",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'(2,3)'"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> str(p1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "aaa018e5-7e3c-462b-8947-2e9a35e467db",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'(2,3)'"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> format (p1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5385bfd6-42c6-4a54-8819-11b942449c20",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "当您执行str(p1)或format(p1)时，Python在内部执行```p1.__str__()```。因此得名特殊函数。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "196ef64b-e14e-4a72-bd90-a252a12435ae",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "skip"
    },
    "tags": []
   },
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93d28ff9-40ce-47af-9f03-a2b2d40192dc",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "继续回到操作符重载。要重载+符号，我们将需要在类中实现__add__()函数。拥有权利的同时也被赋予了重大的责任。我们可以在此函数内做任何喜欢的事情。 但是返回坐标和的Point对象是明智的。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "7c44f5cd-3775-49cb-80e1-8d2ee95309af",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "class Point:\n",
    "    def __init__(self, x = 0, y = 0):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "    \n",
    "    def __str__(self):\n",
    "        return \"({0},{1})\".format(self.x,self.y)\n",
    "    \n",
    "    def __add__(self,other):\n",
    "        x = self.x + other.x\n",
    "        y = self.y + other.y\n",
    "        return Point(x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "1955a63b-5cf9-4dc9-980a-25e4e031acaa",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1,5)\n"
     ]
    }
   ],
   "source": [
    ">>> p1 = Point(2,3)\n",
    ">>> p2 = Point(-1,2)\n",
    ">>> print(p1 + p2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2108501-48f5-495f-ab40-7bcffb7a6eb6",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "实际上发生的是，当您执行p1 + p2时，Python会调用```p1 .__ add __(p2)```，也就是```Point .__ add __(p1，p2)```。 同样，我们也可以重载其他运算符。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "710b7fde-87ff-429d-9b8f-6cdcf25b6657",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0b0a1da-9103-406b-bf4b-c5facda29751",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "### Python中运算符重载的特殊函数"
   ]
  },
  {
   "attachments": {
    "3ddd1a43-e0e6-4cd0-bc4b-ac50f46ab3c9.png": {
     "image/png": "iVBORw0KGgoAAAANSUhEUgAAAv8AAAKWCAYAAADeAPawAAAgAElEQVR4Aey9O68cObat2/8pf0vbG21c7AOUJLfvAxc4zjnWai0IOP5Go9pUASr3oMq9hiBAUFW726oChNoor6zldFzwMfkKksnIZEQyIj4BQkZGMMjJwTEHB5mRuf408Q8EQAAEQAAEQAAEQAAEQOAUCPzpFL2kkyAAAiAAAiAAAiAAAiAAAhPmHxKAAAiAAAiAAAiAAAiAwEkQwPyfZKDpJgiAAAiAAAiAAAiAAAhg/uEACIAACIAACIAACIAACJwEAcz/SQaaboIACIAACIAACIAACIAA5h8OgAAIgAAIgAAIgAAIgMBJEMD8n2Sg6SYIgAAIgAAIgAAIgAAIYP7hAAiAAAiAAAiAAAiAAAicBAHM/0kGmm6CAAiAAAiAAAiAAAiAAOYfDoAACIAACIAACIAACIDASRDA/J9koOkmCIAACIAACIAACIAACGD+4QAIgAAIgAAIgAAIgAAInAQBzP/RBvq/fpz+9te/Tn9t+v+36cf/OhoA9AcEQAAEQAAEQAAEQKCEwG3m/5/fzs3l04/Tb6VWWs7rOr+dfm4p273Mz9O3f60b4d9++Nv0tx98D9X7msH+9p9BkNqQZ/p2tc8qrr9OUV262tL5oM3oUJXPtB+VkTe/TT8+xW3qvv7j52nS8eZwKuBX6rc0Nc3bMpdK592NxQMXa65EjrezRVKM08//ECxUTLbvql+W7ykvcs1yDgRAAARAAARAAARGQeAO8x+aJGPW/tq8AMiY16tGeE3ICuY1avJGQ1raiX/6dvr2Kb9DL2ZfGc/ZAuPpx+nH3Hm1SPj/luz6+7pVe9m2lDFWY6rGRpl//a8wdpmxrxljc+3nYKFhOTQz4zZO3b5pO8Xk2396Y141/9F4Bm/cGIWclutSt339pzf+qsTP/8gthuReXkEABEAABEAABEBgLAQ6mf9pmrSBajVCBQPZvDt9B4hNu7+xMfatqbhzBtGXiI6sqTRmPu5zaIy1YU3q1eesofa7z5PdfTcxhHVE7c7eLInbmHBZgOiqIvMfV55bNJhPSEx/U6Mui4j5fSGumRjCZlU80WKj0NZf/+o+rdF4/uPnKcbMtOPr+nn61i6uqn2QRdGUbzfCLoybYxAAARAAARAAARB4MAIrmH9rqNxOse2hNt3fTj/PzLddMMh1twurDPh8MaFNXLA7HD6KM9nHSNS5yFyGscyMo4pPmbh5W5HpDgYqjWFmcHV8gZmd9dkvLsJ7XV8UBpG5VZiq+uTVB5PbeY76HmAVtqWPpY0I83xss3vt40gpRmKu1XnXHwlX4eB28KU/8liNFFKvhkMlE63xD8dUxW/fz67ZauX8b//1o36Uyhj+oB2LgWpzHrspl/JR6pTIUyzkPK8gAAIgAAIgAAIgMAoC/cy/mHdl3fTz8IH51Y9H/PX6oyNuR1XBYw2XGFSpI9ohNzuv3mSKSQsMpTXezkiq90GdZiCumP/QHIemU/o6qy8ZXmd6k/PBW4WZ70dwIRuvXC/HHdelysXjoZ/fz8SdGlrdkup/pqy6lhpe3Y8n9X2IpD1VWHCQ18DkG87UFx5mDP0Y6wVJspufjV/GyY2dqcM8LmS4EvYjMv8y9v/4UT+iJG3qBePT39yiw/B1voCUkeIVBEAABEAABEAABEZAoJP5T024ee8M92xnPb0uj7Mk5kmZRDGRwc5sBFxYRhYMzuSpksboOTOsys+MrIonaTtjbJ15dQGIiZR25nXoojrGurFVptLF6OrP4OSuqYNy3Lmd+tk5h0NiqKNPC/42/aiec5dxSNoMTbOKSJt//cVoVWeMx9yYW/z+kRsTXVvwnQDbcc0Ds7DwbdlrM5NfPm9iMYb+W9W+61+w86/bkj74/qg+m/FS31mwi5wgLt8qRyAAAiAAAiAAAiAwFgJ3mP/YzKbGVRskMeEzw50xtZGJtyCF58LjEMOZQUtNtDGYLr5ZLKqyson2C5hg51raV3VJH9W5bN2Z++T+4HVuZE3c2pTqvsd4z4x88KtA0c61bkP1L9mJn8Vqjfg/7Sc3Yb80Pub+aFztAimNxWGt7/OfwsR9NBzQ90ZtBaAEnwyYs4KJqtPGq417DRu/UNBjpfliv8j8X+oZfxOfXgzYBVgeP1kEhPH5Tz7MYkK+FB2X4R0IgAAIgAAIgAAIjILAHeY/MZNpj7RhVWWMSfOGUBV8sPmPdrZrxtEbV9091SdnVFW/5oZwbhzlU416O2Yn2f+UqDbZ6rGS1LRHOJcXLakhz753O//yqFYmRltGxfPtD+EnACYQfT74WdPY4MtYewOueeAWbNbAq/sbFjj614x0PLJwSDgoxj7zKY6Y+/i5/aB9Faq73y4gg/cpfm5RqBdRapwSrkTjxBsQAAEQAAEQAAEQGAOB9cy/7NpmDONN5t8ZxgQ4t8hQ53MLjeScNmvp3yQom2hn8lT16l5r/r2ZzBjmkmEP7ve9yLSt+upMrhjcxKjqCjL3+oqDI1VO6glOFw5zu9jS3wgPu/MfnlPl4oWeb2R+LenTbGyS676q+Zdy7b0/q++b6Ofz4/5GfYpMfVxONREt4NKY9L3hPSZG4UUQIocgAAIgAAIgAAIgMBwCK5r/YDfZ7ZZL/5UZTR7PUSYrNajJOb0bHpVJ6zFGLDafuXMSh7y2mWhvIK3hi2KRuky/tSGOTGZukZA/5810atrTONP38e51ulude+/biuP3ZZXRVe2oWMX0mv6re6/v/Pt6I1OtT/t6XKnIbGeuq4JRGRODfI/DjZHG3n8y4867hsoHYZw//1P+uJmMla9T1aDr1djE58u1cwUEQAAEQAAEQAAEHofAqua/9tv/M9OUGH0NSeacWQCIEUsftTBmsb/5N/Uqg6n/wFbwuEz70OViU3dnDLyrVF0Tw+1OBge1e4Niuo1aPbZ/4eNQsmCzCxhl9L2B9nGl46EWDTH+EodpI15s5M5JefWauZ5wIjTq+g698y/P3nt8PN88d/wCZ34u7IO71/1hNoWlYGZx1XGlfAz7wjEIgAAIgAAIgAAIPB6B28x/Y9zaNN1klBsb6FbMm8RslcoAB/1wZjA0y7Nj2QkWk1gyhrW2vcn2cfn6tHkN4mp5bj5neGNDHpj8ZPdcxeDMvl0cqPfh/QobZ5ytIXZthrHqDmXMvTpvFxzmvmDRos8H7z0o7kiPjSxc3NllB25BIXHM6lPjEv50rdRvzod4yBVeQQAEQAAEQAAEQGAEBFY0/xihEQaYGEAABEAABEAABEAABEBAEFjB/PudabcDLK3xCgIgAAIgAAIgAAIgAAIg8DAEVjD/D+sLDYMACIAACIAACIAACIAACFQQwPxXwOESCIAACIAACIAACIAACBwJAcz/kUaTvoAACIAACIAACIAACIBABQHMfwUcLoEACIAACIAACIAACIDAkRDA/B9pNOkLCIAACIAACIAACIAACFQQwPxXwOESCIAACIAACIAACIAACBwJAcz/kUaTvoAACIAACIAACIAACIBABQHMfwUcLoEACIAACIAACIAACIDAkRDA/B9pNOkLCIAACIAACIAACIAACFQQwPxXwOESCIAACIAACIAACIAACBwJAcz/kUaTvoAACIAACIAACIAACIBABQHMfwUcLoEACIAACIAACIAACIDAkRDA/B9pNOkLCIAACIAACIAACIAACFQQwPxXwOESCIAACIAACIAACIAACBwJgcXm/z//8z8n/oMBHIADcAAOwAE4AAfgABwYlwOlBctN5v/Pf/7zxH8wgANwAA7AATgAB+AAHIAD43FALcpK/zD/LGRYyMEBOAAH4AAcgANwAA4ciAOY/wMNJqvr8VbXjAljAgfgAByAA3AADozEAcw/5p/VPByAA3AADsABOAAH4MBJOID5P8lAj7TiJBZ2QOAAHIADcAAOwAE48BgOYP4x/6z04QAcgANwAA7AATgAB07CgW3M/4+/TP/61y/TDxbUv//8x/Svf/2r8P+P6af/8CshKfvHz3+PSPnDL+b+X370ZcMVpNyXXpfzaX3hvRznMQUXcBEOXMs/XU7l/R8/TX9PxfQ/fpr+UPn/yw9RTkvdvMKzmzkg3MrxLuXh7P3fp5/+UPOKn6uKcUg7SVnJi3B+Y66Bz0UezTgIVmC1DQc2MP8iqEpUY2N/dZCdwIYLhT+mn35Wi4nwnByLaP8w/ZK5/sfPP1hxl/LyKvdtA/rVfiMImMJhOBDmr+RL/dWYneC+1IjpzQDMPzrQX29lc+e2haVwtmU+kLLxnGbMvzknsWD++48zuQOmcOA+Dmxg/k2AWhR/+Wn6e7CrXx88a+C1ccgc2x0X2WnxO/wiykrAZRFgxFzE+Jcf7Xl2HjHZw5js+xK5nkv9657nXb4NVe4Xtej+pfZpn11MkI/k48J8FE3PbwYVFqmaZzI3FMrMNo/iOSTb3i8/TCYvlPkP56F8bmyds7THOMABOCAc2Mz8S4N/ll2/mbgGIqwMv35k4A/zeECtrFyT3UVdf7BzYz89EMMvuzBm0oh3bVyMCycg7iOhDs2BlpxN87CSQ2LYJBcPjV0FB/rdVzdkQdrGKzH/wVwhm0Uyl+ixm5t4w1+5L77uzP+P5tG2tlj64gCvwBMOwIFrHFjf/IfGIRRVOW/PaUFNd/7ksZ/0fDShWhEP69bXr+zu2/YRZ5LkWpJwfc4RMVr+E7ekjOS3WhQkuSn3knsJZpGucW1R3slcET2DnzP4gmvmmtQR8TU293/+s7y3j60Jz+2n2mL+/2j97gBjzqddcAAOPIAD65t/1amZqIrw/msyBkDeJzvxcp/sKtZeI8H+s/349V+T7PhnP6Z19SXtPmAgFk10xIdYbMUBMTcuV4JP6IrnZFfU5nWUm5Lrpp7i4mGr/tHOAXLJG/KYT8I14aMYf/Wauea4Hs4HUrepQxau+fnkl+kX/UMUf0w/2Z3/dOGLzodjwDF8gAOP4sBDzL8XUC/K7ly4yy/mPzw3m6wzBiMr4gnJbBl2HxNcZvhy/VHJOWK7Lk//MI/khfmjPr0L3zuDFZh/eeQnNE+xYYNvI477yDE5TmmeiakvLVJlzpFy8l5Mvr/PcFnOS7k6P01+mMWDxBXnRP3+kXEmNsYODhyHA9ubf2fMZdffgunOB7suYv6LO4xeqP0Oi4i6umbr0nUn4o35P8CO33EScQ+iKmZGcs0YHZNX7prknF5EJgtzl89hXgZ5ysKTnFzKATdvzB8vc4vP6FEg0QyZJ+y8IPXojSa5pur8ZfolfITHcTiYe+z8pBaxofl3n3hXN68kHl73oIHECE+PwoHtzX/4zGRi6v/4w/4iSCqWIrjJ+dB8uAFRIv7HT9NP8vHrf/x5+vt/yE98BgsAzD9GY6nROHF5b+5DkxWYpMAAuVyURyuSHdlop19MV9agMdF4LMEih4WaA/74+Sfz087BJ0ymrPAz0H2Xw8E1mV+i+9WOv1qkJjv/UjaciyyHMf9wNMdRzsGLETnwAPNfI4ISZLMrGJmNZJEQPjIQH9sdxT8nOzBa8I2Iu49gMf+Yf2cEapw8+zUxP3OTZRbfsgOaMVhilP74afrB/mG/yPgL/uQiuShcuOnVGvnIvKu8DQz+rF65VuGvvkf4b/ktnL5i/n9xP23r56QRDQAxnV3f6f9Zc2AD85+IbCiaM0GeE9EvAubmIrvzb+s018rCK/VmzUhDXGclDP2ec/TQmGhjnhifcDFe3NVP8p6dfQz+arpquXaT+Z/PK3E+C48rORB86nVt3onrPpmWrDb+4Aiv4MBSDqxv/pV5EFGWXZPQPGSPvdD+oh8Fypv4xeY/bV/iQpQwJnDgOgdc/uTz0f8Nj1+mH+xuvl5cu/tkl7X0es2IIfBLBf4c5b35N497lvhlz+sNqMTUJ/lv5hZfj9skEi6Hm1gB1zH/5Og5co5x3vs4r2/+E1HdO2DET9LDATgAB+AAHIADcAAO7JUDmH8WJ9d3fMEIjOAAHIADcAAOwAE4cAgOYP4h8iGIvNfVN3GzcwQH4AAcgANwAA5syQHMP+Yf8w8H4AAcgANwAA7AAThwEg5g/k8y0FuuKGmLHQw4AAfgAByAA3AADozJAcw/5p+VPhyAA3AADsABOAAH4MBJONDd/KsK+Q8GcAAOwAE4AAfgAByAA3BgTA5MhX9/KpwvnlYDzD8QAIH9IkAO73fsjh453Dz6CNM/EACBrRCo6Snmf6tRoB0QGASBmiAMEiJhnBQBuHnSgafbIAAC3RGo6SnmvzvcVAgCYyNQE4SxIye6oyMAN48+wvQPBEBgKwRqeor532oUaAcEBkGgJgiDhEgYJ0UAbp504Ok2CIBAdwRqeor57w43FYLA2AjUBGHsyInu6AjAzaOPMP0DARDYCoGanmL+txoF2gGBQRCoCcIgIRLGSRGAmycdeLoNAiDQHYGanmL+u8NNhSAwNgI1QRg7cqI7OgJw8+gjTP9AAAS2QqCmp5j/rUaBdkBgEARqgjBIiIRxUgTg5kkHnm6DAAh0R6Cmp5j/7nBTIQiMjUBNEMaOnOiOjgDcPPoI0z8QAIGtEKjpKeZ/q1GgHRAYBIGaIAwSImGcFAG4edKBp9sgAALdEajpKea/O9xUCAJjI1AThLEjJ7qjIwA3jz7C9A8EQGArBGp6ivnfahRoBwQGQaAmCIOESBgnRQBunnTg6TYIgEB3BGp6ivnvDjcVgsDYCNQEYezIie7oCMDNo48w/QMBENgKgZqeYv63GgXaAYFBEKgJwiAhEsZJEYCbJx14ug0CINAdgZqeYv67w02FIDA2AjVBGDtyojs6AnDz6CNM/0AABLZCoKanmP+tRoF2QGAQBGqCMEiIhHFSBODmSQeeboMACHRHoKan65r/3z5Mb15/mH63Xfry7jJdLvn/b76XUtM0Jfd1RUTVfblMUXtNDXyZni+X6flzU2EKgcCwCNQE4fagVX48T19ur6DLnanGkK9dYN2sknW4OU3T5+fp8u7R7GyBsWWeaSnT0tYNZW6ZP+09bu4PPIGOQF9/M3347YZ4uAUEQKCIQE1PNzf/ucn49+/fxGZciUEqEMXuLbmgRPMOkdEi9XiDs6THlAWBFIGaIKRlW96r/DUT+4NzIzV46j0L9pYhHKZMb25O0+/Th9d2wwnzf+c43zJ/KvzDOdeORzq/q1xNz90ZLbeDwNkRqOnpOuY/Xemr3f7XH6YP7/I7563mP93VUxP7kh18bVLunABUDEvaPDv56P94CNQEYWm0Lh+00X6w+c8ErzXjzpzPVMuplRDoyc1p8mZ1Pzxo2dVvKdN/gHrMnzqq7E6/WRTkNgf794QaQeAcCNT0dB3zL7gmq3ktwLXHfnKLBl3emAp1fygOs0WDtJt99RNB9rI+2VBGxcgORRlCrgyPQE0QfPBiMIKdU5WLJSN9i/lP9MG3nTmS+hONCPUgc9e0H9OXi/5859q4aR/jUY+ZNfLhYTxI4pttHEXX1Q655F0w9i1lguLrHObnRr0gUPOhzk95pDfc6c9Eo/uTKaPqKOlLphpOgQAI1BGo6emK5n/+8V5q3iXsmYkPTYEWig7mP6xTGp695gUuLtZSJr6DdyAwEgI1QfBxGhNyiR6TM+dmBkbdpCf/hTv/TTlpI9L1m08Q3beD9LmMiZBOWNN0bYEgxXl9PAJt3BS+tfPhMeb/9+nDO/+dN/1dtvAxNMtPn09+oe0421Jmi2Er5Ko2/8mmgDlX1gI9FrkNtGCu36JLtAECR0egpqfrmX+ZrN1O//P0nOzcC/BXzb8VinTxMLtPKsy8akG6uqvQYuz5eDIDL6d2hEBNEHw38kZf51Fu4tb5Xp7wfb3BUcFQBCX8oa4/NfomF7158sXNIx+JOQwvczwkAm3cFPPfzofHmP8U4piv2VxKFqwtZdJW1nhfmj/1+dkX/Y12uAVMEJApH3+C7y+3zL++NEcgAAJ1BGp6upL5t8n/ffyIjBZgtxiQjwjNazSBh6ZAieGq5t/E6n6JIIovnVwU0Jj/Ot24OjoCNUHwsRcm8JLJL533FZojXS7OfZd7uUWF3F+oP2vqpI1afVIvr0Mh0MZNMf/zxWaWD9P0wMe/5vOLmevihYAfhDDvWsr4O9c8qpr/WZ7l4jbn6l/AV33Pzblr9oy6QeC4CNT0dB3z//nZfCk2MO4KXiXMpd2A0PxHQhPUkd6vyoX31YYwqrNYsEV8jIjl+lGslgsgMBACNUHwYYYmxJ8tPt5TMOfBnfNDdc/MOMyL6TOF+lOzp/N84Q8BFFrk9AMQaOPmTsx/sosvG0fnM/9GSy6zTwhSgrXMv+k9vAcBECghUNPTdcy/RBIYd3UqNe9SLDbxibkO6kjvj++T2gqvTUajRXxayhRi4DQIDIBATRB8eGbCThfX2lznDHvBnPv6MkdNOWnv0/Wnu4LJDqMuk99gyLTOqQERaOOmmP8rfAj6ly4Sg0urHc5zJeZrNqaEwy1lVutAWHEhV3UfZ6beaIfZIDN9blrk68XS/NOcMAyOQQAE2hGo6el45j8VgF7mX//s2zVhaTD2BRFsHw5KgsBjEagJgo/MTODRF351bhbMtTYt1/LL166PluSSrj9+hj81HlmjlDTJ27ERaOOmmP86H8KeNnGjxu+wssbjlJ/mffBT0ZbT/lNkybkgx1rKNMZzXzEV2zy/pU/hr/RorGWDQGOaLtLykei6rn4vL38vZ0EABOYI1PR0c/Pvnu+Nnq0XQYx3RnRXlPhZQdCikr1v3uncGXV/upOZK1c716OOWv1cA4G1EagJgm/bGJHnz96QVJ/X1SZlbg58fXceSf3WDBkdidvL6UOu3J2RcPuKCLRxU8z/8/SlwocwTM2Na8ays/mXx3xkznvz/Rf9B8eiOSiKX5lkybsg+pYyQfG1DnNznzbsrz9MX9wf+osXZPILR4JB+BrhwHfp1ho26j0xAjU93dz8+10OPyJKQJQQhCv/cCKXe9Q5OVZ3y32+pmtHSljbdiGyNenJITYc2XKcBIGBEagJgg87Y0L8xe2PtAEi97YHftsW27gZmP9twzt5a/P5U8y/+/ndWxFS+S2fFtxaB/eBAAhECNT0dF3zH4UxyBttIm5ZAAxmhgaBkzD2h0BNEHxvBuM75t8PzYGP2riJ+X8YBZL5s4v5X/Bo0MP6TcMgsEMEanp6PvO/wwEkZBDoiUBNEHw7mH+PBUdbIdDGTcz/VuNxrZ0u5v9aI1wHARC4CYGanmL+b4KUm0BgvwjUBGG/vSLyIyAwCjfDx07D59Qvr/8yRe/lO2iDPLKizbjEFL6+/l/T/wzfB8fho7RH4BB9AAEQMAjU9BTzD0tA4GQI1AThZFDQ3cEQgJuDDQjhgAAI7BaBmp5i/nc7rAQOArchUBOE22rkLhDogwDc7IMjtYAACIBATU8x//ADBE6GQE0QTgYF3R0MAbg52IAQDgiAwG4RqOkp5n+3w0rgIHAbAjVBuK1G7gKBPgjAzT44UgsIgAAI1PQU8w8/QOBkCNQE4WRQ0N3BEICbgw0I4YAACOwWgZqeYv53O6wEDgK3IVAThNtq5C4Q6IMA3OyDI7WAAAiAQE1PMf/wAwROhkBNEE4GBd0dDAG4OdiAEA4IgMBuEajpKeZ/t8NK4CBwGwI1QbitRu4CgT4IwM0+OFILCIAACNT0FPMPP0DgZAjUBOFkUNDdwRCAm4MNCOGAAAjsFoGanmL+dzusBA4CtyFQE4TbauQuEOiDANzsgyO1gAAIgEBNTzH/8AMEToZATRBOBgXdHQwBuDnYgBAOCIDAbhGo6Snmf7fDSuAgcBsCNUG4rUbuAoE+CMDNPjhSCwiAAAjU9BTzDz9A4GQI1AThZFDQ3cEQgJuDDQjhgAAI7BaBmp7eZP5VhfwHAzgAB+AAHIADcAAOwAE4MCYHSiuXm8z/y8vLxH8wgAP75IASacZun2N39HGDm/Dy6Bynf3B8Kw4oPS39w/yzkMEInowDGCwmn60mn6XtwE24uZQzlIczcCDPAcz/ycwdiZBPBHAxuGCw4MeouQA34eao3CQuuLk3DmD+Mf/s7sMBxwEMFpPYqJMY3ISbo3KTuODm3jiA+cf4OeO3N/ISb3/BxWD1xxSe9sEUbvbBET6CIxyAA5h/zD/mHw44DmCwmBRGNQZwE26Oyk3igpt74wDmH+PnjN/eyEu8/QUXg9UfU3jaB1O42QdH+AiOcAAOYP4x/5h/OOA4gMFiUhjVGMBNuDkqN4kLbu6NA5h/jJ8zfnsjL/H2F1wMVn9M4WkfTOFmHxzhIzjCATiA+cf8Y/7hgOMABotJYVRjADfh5qjcJC64uTcOYP4xfs747Y28xNtfcDFY/TGFp30whZt9cISP4AgH4ADmH/OP+YcDjgMYLCaFUY0B3ISbo3KTuODm3jiA+cf4OeO3N/ISb3/BxWD1xxSe9sEUbvbBET6CIxyAA5h/zD/mHw44DmCwmBRGNQZwE26Oyk3igpt74wDmH+PnjN/eyEu8/QUXg9UfU3jaB1O42QdH+AiOcAAOYP4x/5h/OOA4gMFiUhjVGMBNuDkqN4kLbu6NA48z/7++n1598376ao3Xp7eX6XLJ/3/13VdnTqoA2zrfv71MTx9vIKO6/3KZrrany72a3v96QxsYzbaxBKeH4LSOwfo0PV2epk89x/TjU6wXbz89BK+qHvXsL3VN63DzZXpRXNoVf75O779pmKc244zK78tiDNM5P52z9fVdjQt+AD3cDweGMv9p8isiff3ulTXjDQYiWFAo4cjVVyanqn+BoVcTRrB4Kde7HzLQB8aqt8FS+WsW9T3Nf6oFt5kP+L4vvvfm5suLMdGan7symSOZfxPLsrk2s+Cyi/m4nhvr3mzRs6/8Qe8Yr5AD25t/u7se7fJ/834q7dZ7828Fw+4gprsGUX3uE4R2M69NyqIJAGEKicTxMYSlp8FSOao/RdMTe0/zn8F6izYwFQ/9dKUnN19e/GbP/qJ0FH8AACAASURBVHaYBzL/HTfBsuPQsX7mqIxuomkP1bRHcnJ78y9kS5K6ZubDx3BkMaDKx7sEL9NLsPO/DFQ/ESy6T/Vh0YKB5FuEr3CF180Eqs1gmZ32p4/GhLiFdykXVJ40P/bjjU2kCdc+ZVvUBnm4xzxs42awSZRsNM3mC6srWdO5heZoztpHXQN+5+LRm1OuzI050r1PJo4ZrpKLjfgLF3P9Np/OtG/iSV28onFwoM6BB5l/axqcmL1MKvFnIhI99hN3xJS3H/fbnf5Xb5/c9wgW7eQrsQpiaSaNFreVdzS7C3aMY3NfiWMzA/7IMWkzWJJ34aRszoULddcPMQNNHLLacAn1wJ4rLS7k8Y3idTjvxqJpDMbEq42bYv4vsaZrDoZ89X3Mm05/fRXs9NwRxPPr++m9/Z5aLp6c+VeLbj9nXsuRFfpTmv801u34a3ztQsH3x8er8Mjqyo65vAqnwOMUc3Qv7jzG/Is4uMdznqanJvNvBE4JhDH/XiAMIMqAKDPuy7UAtWihECWYai8Q8OhaGhvvW8aCMo/lSZvByhv92KAE/bjF/KdGvlKHNkvk4eEnvjZuivlPddnMCTkTmTPbq+vQNT4n/I9zq2D0K3Wu0h/VXm7TTMfRjr95BCtZLARz6e3zc6BBQX2rYEH9h9efo/HmAebfGIen7274tZ9gp8GYfyuCdhHx9NGa8Y9x3dcGrSQuxlT4XyCaTxyY/2vYcn1fE1CbwbI5nP6iVsl85M7bnT73yJB7LKhg0nT51FCYOC4Y/1NMvG3cFPM//0S2ZPJL59fVLuHufFc7F0/O/M/mo2yOrKg/VfPfiL/WhrLxV2NQmp/XHZ8VcWOhcAq9Gp2f25v/j0/mIzwlVMGugRK83Ed+KvGdyCmh0DsixiCYZ46NITD3+8VArq7SYNwuLpj/Eqac3+fk0WawOpj/4gTYaP5l8RBoCJzbJ+dax62Nm3sx/3asxPwGj/Ccxfzrebfhp7Vvn5+PnQ+teUM5eJDjwPbmXyb9G8y/EkWzEBDT7c2+PP+ohWKpISjtYEispVdtQOY7HDmgOUcC7oEDbQbLmH+3KLf5Ucw9bXBa88TmdPLYg/4tdvfpgGmfL9ufK6fauCnmP/2UqLCofDGPkD6aS6Hhz+WRvu7mtZYc2YAbpflP5/sV/O2ip2WTzs/7G/SpNNdznt36g3FgR+ZfDL8Vdy2ESgQDkYl2A5Nr1YFTdbeaEy9A7Eh4LPZgbInx+ni1GSxrvsPHbWzuZSfzW8x/sBMqzwS7xcai+q73GV7sA6M2bor5jx8l0Vpd0PjQeBe5UON3dW4pYPvxKfikO1mYpObZGmX/fL01/7UcuSWmxfcU5thZvPbRnQD/Jsx1PMG8vzi+AvbUg5GHA/qPJk6Ff38qnC+ebhZnBbwSU7eTYXdf3BeA/XP2akdfT/pKUJzhzzwi5MTZCKP+TkEgNkVRtyRYvrtg20mfe4ZUCMuOOdCWw8b8m+/Y+FzNGn+FhTYDrYtrk1evvvuk/4qpfCfAGX9Xn29Xysinf9dynev7NEVt3Az4JiZUzytl/jUZUTe/9MLO8NxxN/mkS8ck8+E376dP6o/lufmyIUc20qDsBpjkewX/qH/Sz9w4qTpcv3thTz1oIBxQelr6t7n5z5kHJS7pxB+91yInZsQOqBXqZR/lLtxhQJQw+RtNsFsKdZvBSvKtKw5ibL7Cr6647n+ya+NmYP7Bb4McMvkazd1i/u/GP1P33XXuPw+2nA9o67h8eZz5HzGJtWgFjxGVYtSLi4Zypfs5v8GkdNykXVOQ2wwW5n/NMaDufO62cRPzvzl/0k9FOpn/pk9kmEuZS+HATRzA/EOcm4iz+QTDOG0yTm0GC/MP//MGfU1c2riJ+V9zDJrq7mT+m9piXthkXmAstte7tTHH/CMeiAcccBxoNlhg5jBbW6Sp30y8o3Cz+Lz6N/82uWf4w+fYH/7Mulms52L7P/+v/Hdnlj0yezxjRM4xpkfnAOYfE4OJgQOOA6MYrKMLL/1bbi7g5nLM4BmYwQE4kOMA5h/j54xfjiCcO5dwYLDONd57ym+4CTf3xFdiha8jcwDzj/nH/MMBxwEMFhPWqBMW3ISbo3KTuODm3jiA+cf4OeO3N/ISb3/BxWD1xxSe9sEUbvbBET6CIxyAA5h/zD/mHw44DmCwmBRGNQZwE26Oyk3igpt74wDmH+PnjN/eyEu8/QUXg9UfU3jaB1O42QdH+AiOcAAOYP4x/5h/OOA4gMFiUhjVGMBNuDkqN4kLbu6NA5h/jJ8zfnsjL/H2F1wMVn9M4WkfTOFmHxzhIzjCATiA+cf8Y/7hgOMABotJYVRjADfh5qjcJC64uTcOYP4xfs747Y28xNtfcDFY/TGFp30whZt9cISP4AgH4ADmH/OP+YcDjgMYLCaFUY0B3ISbo3KTuODm3jiA+cf4OeO3N/ISb3/BxWD1xxSe9sEUbvbBET6CIxyAA5h/zD/mHw44DmCwmBRGNQZwE26Oyk3igpt740B3868q5D8YwAE4AAfgAByAA3AADsCBMTkwFf79qXC+eFoNMP9AAAT2iwA5vN+xO3rkcPPoI0z/QAAEtkKgpqeY/61GgXZAYBAEaoIwSIiEcVIE4OZJB55ugwAIdEegpqeY/+5wUyEIjI1ATRDGjpzojo4A3Dz6CNM/EACBrRCo6Snmf6tRoB0QGASBmiAMEiJhnBQBuHnSgafbIAAC3RGo6SnmvzvcVAgCYyNQE4SxIye6oyMAN48+wvQPBEBgKwRqeor532oUaAcEBkGgJgiDhEgYJ0UAbp504Ok2CIBAdwRqeor57w43FYLA2AjUBGHsyInu6AjAzaOPMP0DARDYCoGanmL+txoF2gGBQRCoCcIgIRLGSRGAmycdeLoNAiDQHYGanmL+u8NNhSAwNgI1QRg7cqI7OgJw8+gjTP9AAAS2QqCmp5j/rUaBdkBgEARqgjBIiIRxUgTg5kkHnm6DAAh0R6Cmp5j/7nBTIQiMjUBNEMaOnOiOjgDcPPoI0z8QAIGtEKjpKeZ/q1GgHRAYBIGaIAwSImGcFAG4edKBp9sgAALdEajpKea/O9xUCAJjI1AThLEjJ7qjIwA3jz7C9A8EQGArBGp6ivnfahRoBwQGQaAmCIOESBgnRQBunnTg6TYIgEB3BGp6ivnvDjcVgsDYCNQEYezIie7oCMDNo48w/QMBENgKgZqeYv63GgXaAYFBEKgJwiAhEsZJEYCbJx14ug0CINAdgZqermv+f/swvXn9YfrddunLu8t0ueT/v/leStX7H9fxPH2pF59fVTFdLlPc3pfp+fJm+vBbWFydu0zPn8NzHIPA/hGoCcLtvVP50piPn5+nS6ALt7c5TbEekK/3YDnCvetwc5omxbl3i2eLESCZx6D60ppr87vvOvP792+my2yuvFKlnXPd3J/mvr6ezr9X6uQyCIDAVQRqerq5+c+ZaSUozoxrYcsvEJR45O6/ioArkDP56uLv04fXGeOiRSlz3tXHAQjsD4GaINzSG2MIVM425orKqx5GLDV0Vjvu04hbEOCeXgj05qbRdjuf9OBcr47eU8+jzL9qNzXuV/uh5tbQ2Kv3l3k9N9V9tXEKgMCpEajp6TrmP13pq93+1x+mD+/y5j0y/7mhUvUtFp15RdqkRBOA2d2/vFOxmfhSA6N2Ft3CZF4lZ0BgdwjUBGFpZ1x+tBgSXeYyPX//wfxXuhDl49LW5+X1JwGd65y3wpm1EOjJzWnymz2H4kVLrnUfIGPauyystT8IFwQq2I71d+87FYLAPhGo6ek65l9wSlbzWoBrj/3kFg2F8u4jxNbdxmAikPDcq5iS3CM+nRYeri0OQODBCNQEwYdmFsbPn+1OneRhyVgvMCRGB658SiD1JZpwzXwcyuT5wTjNURs37WM8Svsb+fEYXkgO2U0mnUPW9No5x8xjYS7IPeGQmxx0m1CSG2GRtY9Vm7MNOB9XNLfPyiXB6TFLzf/BHs1KusxbEHgEAjU9XdH8W9MQCIESiNzknd351wJhRVEdSz1ZEWqAtXifilMJkRLdUISlTnU+I1RymVcQ2BkCNUHwXRHDEnLfnHMmxBc2z1Rn8ycsNE2T5LLKx9JCQt2iriuzJHnvzoXxZOq++9HApE7ebopAGzeX8+OR5j/8NNmZZMdrO0+6XDA5Fs+T3mTrwdC5kZur1hsqFfc8723sUc6l/ZnHpDFw/Q+uh3N+cJpDEACB2xCo6el65l8mb9kxvDxPz1fNvxgOeea/YP5dnTlByoM0f+THlgtMSHYRwseReUA5u1sEaoLgO5U3+jqPchN3oyFRE78xNsokVIy8ri+9npggH+xkHvFIFgvRdd7sAYE2bor5b+eHNpzOYG+FRCaHtMGVHDBxxDk1ovk3eRcvSFTsBaNf0QLd12ixEI6F6ns6puF1jkEABJYgUNPTlcy/FbDvgx17NT0v+bWfYBfA3GdFQQmLmI+gzDVAtOjcJP4l4bvWItdBYEwEaoLgI86ZEDFdmV3HyoTv61xwVKgva+J0WYz/AnSHLdrGzTIPs/yQuecm/b8HqkwO6TkrNrh7N/+zTwQyfXQLhaLxVzhj/u9hG/eCQIpATU/XMf+fn81HhEoExKhbAZ7vHkyTEj8vIEYw3bOQ2uy/0T/PaUx/eL39C4OY/5QWvD8rAjVB8JhkjIu6WDDlxfO+wmVHhXZSc6fzevbTvcuaovQ4CLRxs8zDlB/Ss9J5ub7OayaHMsb4+OZf5uzMpkEEvCoXL4yiy7wBARBYhEBNT9cx/xLeUvOvhTEQCHlv6/mifmP41t0bvYjwf3NAQrz+iiBdx4gSe0KgJgi+H2bC9otycyU2Kr70OuY/NQLJYz96gRA/QhFExOEOEWjjppj/K/wI+r8f859wXPchycXCwjjobvdDhV+qBW43P52To/jso0HBJmAxOJnviwW4AAIgsASBmp6OZf7DXmkhsOJuzb/6M2C3i7gS0GBhEbZVO7550VCrlGsg8DgEaoLgozKGI/qDPjonC2Y7mvB9LTcf6friR3nMLr/P4du14OaouHFlBNq4Kea/zo8w1Cau1PgdVtZ8bHIo+rQ7nNdsPemCWscamGX9Pvx0q3eutfRHtZmafHnmP3qUJ1moZPpbak7jMGujVJrzIAAC1xCo6enm5t//RKd8qde8hrsKRuz8JO9+IcT2NDUB1wCQ66resB05X3u95Z5afVwDgUcjUBMEH5sYF1kEmDyNjIwvXH4cKCyz5FgMjiwC9Jf8A02QjYDgy/9eW+JyS5ql7GMRaOOmmP/n6UuFH2FP9JxyzVgOYv7dl9ctt998/0X/YSw3d0luhB1c/VjpQOmTFhOf5J+LU8VkMZVr4WtUjh/WWH0EaeB8CNT0dHPznzMPysxrIbBCPiujBCTYCTFDKKZkyUSfE7AKIbRwLam/UheXQGAQBGqC4EM0+TXLRV9g3aOHGJx1u0Tt1xFo42Zg/q9XSYleCKicjObh3CNKNzY2q/vGergNBEDAIVDT03XNvwthoANtKtIdjFx8DzY/uZA4BwIdEKgJgq/+wfzH/PuhONFRGzcx/4+ihP4ExS0AOpl/vcnWMic/qte0CwL7RKCmp+cz//scQ6IGgW4I1ATBN4L591hwtBUCbdzE/G81HvV2Opn/eiNcBQEQuBGBmp5i/m8EldtAYK8I1ARhr30i7mMgMAo39Q537vskr/9i/vJ0es3thj92HMz34eLv0+nn7P/9v0//LY1Zv2fH/bEjRusgsB4CNT3F/K+HOzWDwJAI1ARhyIAJ6jQIwM3TDDUdBQEQWBmBmp5i/lcGn+pBYDQEaoIwWqzEcy4E4Oa5xpveggAIrIdATU8x/+vhTs0gMCQCNUEYMmCCOg0CcPM0Q01HQQAEVkagpqeY/5XBp3oQGA2BmiCMFivxnAsBuHmu8aa3IAAC6yFQ01PM/3q4UzMIDIlATRCGDJigToMA3DzNUNNREACBlRGo6Snmf2XwqR4ERkOgJgijxUo850IAbp5rvOktCIDAegjU9BTzvx7u1AwCQyJQE4QhAyao0yAAN08z1HQUBEBgZQRqeor5Xxl8qgeB0RCoCcJosRLPuRCAm+cab3oLAiCwHgI1PcX8r4c7NYPAkAjUBGHIgAnqNAjAzdMMNR0FARBYGYGanmL+Vwaf6kFgNARqgjBarMRzLgTg5rnGm96CAAish0BNTzH/6+FOzSAwJAI1QRgyYII6DQJw8zRDTUdBAARWRqCmp5j/lcGnehAYDYGaIIwWK/GcCwG4ea7xprcgAALrIVDTU8z/erhTMwgMiUBNEIYMmKBOgwDcPM1Q01EQAIGVEajp6U3mX1XIfzCAA3AADsABOAAH4AAcgANjcqC0vrjJ/L+8vEz8BwM4sE8OKJFm7PY5dkcfN7gJL4/OcfoHx7figNLT0j/MPwsZjODJOIDBYvLZavJZ2g7chJtLOUN5OAMH8hzA/J/M3JEI+UQAF4MLBgt+jJoLcBNujspN4oKbe+MA5h/zz+4+HHAcwGAxiY06icFNuDkqN4kLbu6NA5h/jJ8zfnsjL/H2F1wMVn9M4WkfTOFmHxzhIzjCATiA+cf8Y/7hgOMABotJYVRjADfh5qjcJC64uTcOYP4xfs747Y28xNtfcDFY/TGFp30whZt9cISP4AgH4ADmH/OP+YcDjgMYLCaFUY0B3ISbo3KTuODm3jiA+cf4OeO3N/ISb3/BxWD1xxSe9sEUbvbBET6CIxyAA5h/zD/mHw44DmCwmBRGNQZwE26Oyk3igpt74wDmH+PnjN/eyEu8/QUXg9UfU3jaB1O42QdH+AiOcAAOYP4x/5h/OOA4gMFiUhjVGMBNuDkqN4kLbu6NA5h/jJ8zfnsjL/H2F1wMVn9M4WkfTOFmHxzhIzjCATiA+cf8Y/7hgOMABotJYVRjADfh5qjcJC64uTcOYP4xfs747Y28xNtfcDFY/TGFp30whZt9cISP4AgH4ADmH/OP+YcDjgMYLCaFUY0B3ISbo3KTuODm3jgwjvn/9f306vI0fXp5mb5+92q6fPN++hqZsk/T0+UyXZb8f/vJmZqmgdExXKZX330N7lPtvpre/5qS++v0/pvL9PQxPp+PPS7TFEvUd+4Hs204sI7BUjlkcvvqOH58yuS+6ns+367Wl8sj1UaoI0t1Ilcn5wLNXIer63DzZXpRfIADncfPzteLcDU57nMznXdNnemce5MGkK+dx3udnGds18N1TPP/69fMAmCBgVCJvVjQVf2p2IjpyBuXT29z5V+mT2/TBcR6A0hygG1PDvQ2WHoxrI12PodmsasFeMEwlPJtVkd1Yk91xBgKzN/4edSbm7Kg1GazwLll3Bofw236c9tCXWlFuPFmtCOZY4NNwm36wpiC8zE5sL35t7vrfnXfspsfGIeW+2efGlwfPC000QQgpuD99P6t+q/iVHHY3Ylv1Lmn6b36lCJdNCBQ7CpUDeh1Pj5KcHsaLLcI1jvtQQ7nsLG78U/fvZ/0f7Vg0PnYkG+5+paca4lvSX2UXSX/e3Lz5cVv9iiesvjrqEkqn26Yg+eaZ3I/XBCoMk5XyLNV8mw+Dh25wZgNM2bbm//S4LcaZlWuJizXrmfb9xPBjPhiSpLHe150vOUdfiVQfDyJaMz4lOXfODi1GSyzMH76aI25PEITLZ6DPi0w19qI5R4RupJvBmdvFkw9dmOhphdqPBbEt7fxPFK8bdwMxtNyRjaaSnqsuVLi7mr52p5DEZcv4bzi+e7GWXM53i3ftn8mphnWkmONY5Lms+ufGg9Vx7WcXm3cAl2jjWGMbMQPxqVpXB5k/jOilZvclWCkSZ6Ihwh79Jrec40MuXb0PSpOJaRKqOOdSyWoxvzEQisknH+SgGgINryOy4U2g2WMS/yJlzmX7tLpsZaJ/1oeyqSuyidm7Fq+GU4ZXVFa4M2HPZfU5zl47fq4Y+X7cI4Y27gp5v8Szx2ag3mt3tYcy1i15JDlZjif2flP+K3nmeC6eVQm3JQydUj51Tmj44vnSt2mxr99TPw9uTFT2OXOC7a8rj7O17Sc600G/JHj9CDzb5IzEl1n6lVSW9FTCf7xa/zFXzEIJXJdu565r2jUAxOiyjhjE7YRlIkGUp0PRDm6lomB6wj2CBxoM1h5o58aEdcfPfFnDEGSB8bgKx6o/A8m95Z803VZ3UiNfqV9rUEYieEnKsWlNm6K+Q/4E3DDaXjAvWgeCs47/q5yriGHNG/TfiQ/iBFx2/D/1Tev/OJZ5U6ycbVqv1Q8uXkv2xcbb/QDG3Ye0HGXHscy9222oFll/JnvVuUhY3ZV0x9q/qPBtyJlnqEvJb39yE8eMyi95sSnQoai+a/cE8WeK1cSwVxZzl0l6lW8wbALhm0GyxiX2eQbGZFgciud7z5mBTOhtSU1UaYP8acXQczdY6Pue3O4jZti/ueLzZLJL52/N976/ddzqG0xHdajjp+mT6Hh33oeKrVX0IAc9rrf7js/ubzB/Ne5lcOMc2AWc2AA828S2Ty2YwTbJH86WceBh1/YundQMf8ptry/l1N7vb/NYIWGI+BKYYLf7pn6RvMvu4oLNwn2OqZHibuNm2cz/8EXYJ3xVnlg5k9lrnOfdqzGCRdDoAtqIV3QhtT86/fRY3tJPXpRjvlfbfzY9OiyibaH8Xmc+ddioL6QZ01+uFvhxCL4BEAm7NJuf+586+ReEqw7EmGVBcUd8eyBjMSYm+i2PddmsIz5T02F5nwu5woTf//xthsJ1cd+TOzpdwr6x7LtuJ0h/jZuitFMN48KC0P76zHb86Ehhwp5M8szO399Ch5NNab/k1sEbMaPdB6XOUv3pT4mul/iB+S+7KvCLq2LfNtsjLNjAv57w3978y8mPp2gC6JhdgL8R7jpe/3N/6Cu2fUmoiox8W3cP4jsTNyPIWLyCAzbDJY10OEEbPN69iiQyr+CienfP2v+o53DxGRtFgv87T2+bdwUvsVfLjXGMq/xes4I5pBs3DV+N80xKR9acsjyOVxQ5+LQ515N6ll/98co9YJAnUv/WGYaR+/3KuYgDsFG511tTExf0w2F7Fjovm3dr944UV92bIUvvK7+CcT25r80qFrA8uKsSWLF4+mjiGbl7wO8fbJ/DbhSXxKHmgCahCe5L0vga31pqYMyq5M/O3Ynx73NYJkcTHMxa/wVnjp323Px9nERA6F2PL0+RHktJiTzSWEx/pNz4vbx6Gtw2rgZ8C0a6zL/Hmn+r+eQXQA4vmaMdfC3Z746rtp58tqixpXvN1Z6oZW2KxpQHJO0nz5/0y8Qd52rV+j/KPlCHP04fUQsH27+tfCKsKWCkU1MJWqBkCujHd6Xvs/WkSOFqjcnrLmy9XOIUx2fIybSUfrUZrDE/I82zmL+v7JwbNa90cawHE8bNwPzPzQGo+ZQGf92jTN5GC2mxfzfOyZsrKFt93KI+zWHHm7+2wWlIEpi9rUomN2CaKdvyUBrgbpvATB7HnNJ+5RF2B7MgTaDNapxwfzfracP5l8t/jZuYv5rGG52zc7HbgHQxfyPqjsFbzJwLm3GAzAY1tPs3/xDrmHJhcDsb1JoM1ijTsKY/yPnXBs3Mf9DcqCL+d+fng45FngmPJP9uylT4d+fCueLp5vFGfJBPjgwJAfIYQzGqIZlFG5Gj6rKI6vq9Zt/m6K/NC/XNv/SbQOHg0/K45hfTe/+R/C8vfRBvYaP16LfQ+r3qLlLXA05uXFOKT0t/cP8bzwYJMh4CXK2MRnFYJ0Nd/p7Pffh5nWM4BEYwQE40MIBzD8Gnx0MOOA4gMFi4miZOB5RBm7CzUfwjjbh3RE5gPnH+Dnjd0SC06dlwo3BWoYX/NoOL7i5HdbwGqzhwLE5gPnH/GP+4YDjAAbr2IK/5wkdbsLNPfOX2OHvSBzA/GP8nPEbiZjE8hihxGA9Bnf4fh13uHkdI3gERnAADrRwAPOP+cf8wwHHAQwWE0fLxPGIMnATbj6Cd7QJ747IAcw/xs8ZvyMSnD4tE24M1jK84Nd2eMHN7bCG12ANB47NAcw/5h/zDwccBzBYxxb8PU/ocBNu7pm/xA5/R+IA5h/j54zfSMQklscIJQbrMbjD9+u4w83rGMEjMIIDcKCFA5h/zD/mHw44DmCwmDhaJo5HlIGbcPMRvKNNeHdEDmD+MX7O+B2R4PRpmXBjsJbhBb+2wwtuboc1vAZrOHBsDmD+Mf+YfzjgOIDBOrbg73lCh5twc8/8JXb4OxIHMP8YP2f8RiImsTxGKDFYj8Edvl/HHW5exwgegREcgAMtHOhu/lWF/AcDOAAH4AAcgANwAA7AATgwJgemwr8/Fc4XT6sB5h8IgMB+ESCH9zt2R48cbh59hOkfCIDAVgjU9BTzv9Uo0A4IDIJATRAGCZEwTooA3DzpwNNtEACB7gjU9BTz3x1uKgSBsRGoCcLYkRPd0RGAm0cfYfoHAiCwFQI1PcX8bzUKtAMCgyBQE4RBQiSMkyIAN0868HQbBECgOwI1PcX8d4ebCkFgbARqgjB25ER3dATg5tFHmP6BAAhshUBNTzH/W40C7YDAIAjUBGGQEAnjpAjAzZMOPN0GARDojkBNTzH/3eGmQhAYG4GaIIwdOdEdHQG4efQRpn8gAAJbIVDTU8z/VqNAOyAwCAI1QRgkRMI4KQJw86QDT7dBAAS6I1DTU8x/d7ipEATGRqAmCGNHTnRHRwBuHn2E6R8IgMBWCNT0FPO/1SjQDggMgkBNEAYJkTBOigDcPOnA020QAIHuCNT0FPPfHW4qBIGxEagJwtiRE93REYCbRx9h+gcCILAVAjU9xfxvNQq0AwKDIFAThEFCJIyTIgA3TzrwdBsEQKA7AjU9xfx3h5sKQWBsBGqCMHbkRHd0BODm0UeY/oEACGyFQE1PMf9bjQLtgMAgCNQEYZAQCeOkCMDNkw483QYBEOiOQE1P4svZnAAAIABJREFUMf/d4aZCEBgbgZogjB050R0dAbh59BGmfyAAAlshUNNTzP9Wo0A7IDAIAjVBGCREwjgpAnDzpANPt0EABLojUNPTdc3/bx+mN68/TL/bLn15d5kul/z/N9+rUr9PH16H199MH34L8Pj8PF0uybngctOhiulymUx76R1fpufLZXr+PE2TLndnW2n1vAeBARCoCcLt4anceZ6+LKlA5/PCe8L6bS47TQm0JizG8X4QWIeb0zQprr1bxM79gFaJ9Pfv30wXlxd2fh0QB+MNlmlB6if0vB1goa8P2NcgRA5BYFUEanq6uflPE1T1XAlUaP69+Q7EwJrx53ehmC3FTRmUsqGPhdJOGE44l7ZFeRAYE4GaINwSsc4bvagP8vVqRcaI5BfhV2+2GwVhLltjQ762gDdsmd7cjDaUHmAEZ3PKxsjH7Y9p/nWMS8cmXczpjQS7cecwNv3NeQ5XhAMQODACNT1dx/ynO3LKGLz+MH14lyanQV0lf2r+/TnZhff33rqir4tMzowgHgfOi9N2rSYIS0FRuahzd+ku/hqfrK1R51JAKH8XAj25OU1+s+fWOeOuztiNLb/zfm9ty+/Xc97QC2I/Rst7F9+RHWOlS0P3P+4D70CgJwI1PV3H/Ev0SeLp5Gx47Of5c/AIQXZFbz4tuCx6zOCKyJSMg2p/6a6E9J9XEBgQgZog+HBVvqgFt90tlLwt5YLO0/ad/2umxF23+W8e7Ql3+n2k7qiUw64AB6Mj0MZN+6ms0n895v5R0dIub9YYrgpGkjcqf3TuyCbTF/eIq4rZ8T2MKZNTupzkYmb+i+bYd1+SeqXt4BHbJJ9N/e15HIZ7y7FuL4nBLNoWaI9tOD/Gqs9XdOOWwLkHBHaAQE1PVzT/VvyCVbdKzpw4KwGIdv6/V8/lP09ftPi9mfSjPk7wAqHX5RoTW9UVxJKOW1445FOH7cQwjYv3INAbgZog+LaM+Y+/Y2POZR/VyRgVX1d6JAuL9Lx/70xOYAyuGROdw5Uc97VzNCoCbdwU828+UZbvlOnn+guPdRb1fWUgNGcjTtp5MYlzXk766OeelN/pPfp6uCDQORliFJr/3IIjvr4yNO47fnNPsFB7VKB2ETiva5oULlnNWr+DtAACD0WgpqfrmX8RHmfan6fnVvMvOyHBxG8QVKLQaPYTyLVQzuqTQjUzcnubUjuvIDASAjVB8HGanEgnzdRwuPJLzH9DWd1OaGR0Q+U8NeXzmwsuRg6GR6CNm2KM07mgbF6HM//JXJTNqzBPsp9qhXNTPjfiBUOCT1pn+n51toTxh42ZvjRrj368K1zkhHXZRU6Cd1yCdyBwTARqerqS+bdCpHbmg10PszPhd+7dr3S4X98x4qRX71qIzIIhLDc7bkxqLa6lsqHIzjhQEqhZQU6AwC4QqAmC74DNYfXLV+G/Uq6Uzof32uMWI5Y1Q/bXwGJTYDRD6UJu1y/TPKcGRqCNm2L+/a64dKnErdJ5uW+t1zmPEwNuG56XS/qo8ys/d2reF/IvrjdtO34fl10LkbDe0ty6QHsEl8BnhC2oY92v0tyfFuY9CBwIgZqermP+Pz+bj9mUgQ+SUglwboJWyWkmdCNGofmPf5ytJBbXR6ssALEAzmu6vc15XZwBgccjUBMEH92CCVjdVDAfvj571Li7mDciaa6aGJd992cWEScGQqCNm2W+lUx+6fzaXZ/zOOWwiWBeLunjtfwqXI/rnbftr8+vrY1N+IXsuK027dGxu43DuIbwnS6H+Q8h4fgkCNT0dB3zL8DeaP7d7r5NWCXcZnEgRlwJ1XzXR5rNvipxDBYirsw1M6KvL2zLVc4BCIyHQE0QfLRmAo532XPPCds7CubD12eOvNlIr8TvzcSe5l1oCoxZyeZ0XBXvdoRAGzfFGO/3sZ80r3KL5ygH9DyU3zzTw5udx9IcyRh8ue+z/Z7dplwx8cw3BBu0R+tNBY+gH94/BCc5BIETIFDT0yHNfygG8apdzH/9Cz75MVX3pmaiYmZsJXH7+Zo5CwJ7QqAmCL4fZgKOvvBbMyBN5j9jPnyD0ZExPvILKeaS3r2VBbyYlvCPAEY18GaPCLRxU8x//Jx3ZJaTzjft/Nf4ndTX+nYeUyEH0rbt+/BTLd2HaA77Mj1LPsgfyHTv7dymvnPnzuXatgb83WN+1U7hM1sIyTP84ff7EnyaxlMPUuAZWgeNciBwEARqerq5+Xe7+u6LwOY5RiMAVojkOWOV8E641GikiZw39KVxU4IRC40xOOFiI743iSe+yDsQ2CUCNUHwHZLcMK+St8VcaTH/LWVsANo0vf4wfVF/oVS0ItQCZ47mz0HHOe57xNH4CLRxU8y//CKccGC+uSM9bjKLicGUe+97DfJHf5KdM+CmBbNQCPoyyxdzr8uHaCGg6kiuV3/qM+iVbqdtFz24q8+hxjwdt+vaYxZCglX4mtSl+hbqRp+oqQUEdoFATU83N/858+BX/yWzHQjoXYms6gk+Kp6JazKeCEcCCG+PgEBNEHz/ZAL2Z+49ajJgthEx/+5nHO9tnPt3gUAbNwPzv4teEWQNAZ3r0TP5vbSn5Cdq0XANBI6DQE1P1zX/I2KoDb9aANhdkkh0goD1jkSwUAgucQgCe0agJgi+X70mYFvjwl1VzL8fiTMdtXET838sTqRzcR/tWbLZcCw86Q0IGARqeno+8w8rQODkCNQEwUPTZwL29S07wvwvw+sopdu4ifk/ynjn+/FY7cnHxFkQ2B8CNT3F/O9vPIkYBO5CoCYId1XMzSBwJwKjcLP4TPnrv/jvoMh3UaIv1d4JwKC3g8egA0NYIFBBoKanmP8KcFwCgSMiUBOEI/aXPu0HAbi5n7EiUhAAgbERqOkp5n/ssSM6EOiOQE0QujdGhSCwAAG4uQAsioIACIBABYGanmL+K8BxCQSOiEBNEI7YX/q0HwTg5n7GikhBAATGRqCmp5j/sceO6ECgOwI1QejeGBWCwAIE4OYCsCgKAiAAAhUEanqK+a8AxyUQOCICNUE4Yn/p034QgJv7GSsiBQEQGBuBmp5i/sceO6IDge4I1AShe2NUCAILEICbC8CiKAiAAAhUEKjpKea/AhyXQOCICNQE4Yj9pU/7QQBu7mesiBQEQGBsBGp6ivkfe+yIDgS6I1AThO6NUSEILEAAbi4Ai6IgAAIgUEGgpqeY/wpwXAKBIyJQE4Qj9pc+7QcBuLmfsSJSEACBsRGo6Snmf+yxIzoQ6I5ATRC6N0aFILAAAbi5ACyKggAIgEAFgZqeYv4rwHEJBI6IQE0Qjthf+rQfBODmfsaKSEEABMZGoKanmP+xx47oQKA7AjVB6N4YFYLAAgTg5gKwKAoCIAACFQRqeor5rwDHJRA4IgI1QThif+nTfhCAm/sZKyIFARAYG4Gant5k/lWF/AcDOAAH4AAcgANwAA7AATgwJgdKy5ObzP/Ly8vEfzCAA/vkgBJpxm6fY3f0cYOb8PLoHKd/cHwrDig9Lf3D/LOQwQiejAMYLCafrSafpe3ATbi5lDOUhzNwIM8BzP/JzB2JkE8EcDG4YLDgx6i5ADfh5qjcJC64uTcOYP4x/+zuwwHHAQwWk9iokxjchJujcpO44ObeOID5x/g547c38hJvf8HFYPXHFJ72wRRu9sERPoIjHIADmH/MP+YfDjgOYLCYFEY1BnATbo7KTeKCm3vjAOYf4+eM397IS7z9BReD1R9TeNoHU7jZB0f4CI5wAA5g/jH/mH844DiAwWJSGNUYwE24OSo3iQtu7o0DmH+MnzN+eyMv8fYXXAxWf0zhaR9M4WYfHOEjOMIBOID5x/xj/uGA4wAGi0lhVGMAN+HmqNwkLri5Nw5g/jF+zvjtjbzE219wMVj9MYWnfTCFm31whI/gCAfgAOYf84/5hwOOAxgsJoVRjQHchJujcpO44ObeOID5x/g547c38hJvf8HFYPXHFJ72wRRu9sERPoIjHIADmH/MP+YfDjgOYLCYFEY1BnATbo7KTeKCm3vjAOYf4+eM397IS7z9BReD1R9TeNoHU7jZB0f4CI5wAA5g/jH/mH844DiAwWJSGNUYwE24OSo3iQtu7o0DDzb/n6any6vp/a8xcT69vUyvvvvqDIkB9ev0/pvLdLnI/+S+j0/TJVPXogH59f306pJrW8WnYr1MTx/jWMPzX797NV2+eT99xUwmY5dixvtFvNyQT+sYLJU7T9OnJf3Q+Zy5p3S+tW6b405HyNfd5Oo63HyZXhSn3n56CA5qrtNc1DwszTEb6aXODT+v6vlsad625uEd5UxcPs4mLb2W90nfm+q8ow/UvxGnGaOirm1v/tMkdGb+Yo1zySgY86/Nt64jMAY2cZ/e3mO+VbtlQSkZ+/R8fuEC0RG7fXCgt8EyE7UyOEG+XhVkk+ulDYD5+VZsVb1hjtsNBRYAxQlipLztzc2XFzv+ag56hPmfLWQx/1f5pjBbnK+NeX9T3a3aQ7mrY3t1XgDDnhhub/5fXiZlCMwE7g23NglvP01uJyRcFOgddyPUyvz7+1+mF7uYkB15ff8NQi7t58E1bc9NR+Z8ujCB0LswFvlxP5/Y9DRYbiE8MzlXcLWL+fQTQZProXm/Uk9L7pXaarmXMpvmdk9umk9sDZdunTPu1Qw950RGdizzf2//+t/vPcDddWfzvmP9aMOm2nA3H044Xg8z/+5j98Tkv/ru0/T+O/kIViWjTPaSmEog7S6iNhXzR3G0qEqZpkH1i5AsibJCIQsPic8bETWZyGIkW19TTL4+6gCLrTjQZrDEpJicdLlcWnQvNP9zU2TGv3TeYGNiUQt0beZEVyJzleFRKbfJ0eEm7zZu2sd4lP7rsZXHRMua/AjzH3HUffIgeRXy1JxzOZab15J+pjvjkjef1GOpri3BSfARvPx8Jvepx1h1vGku6bz25VfXKNVeGoP99KZb3qs2SjqGJgynCatz7sBj/hDzH07WRtSSRwI+PulPBrT4uES05v879Vz+0/TJCo9+1Ecm+uD1SZdrFKasqHgBLk0OpfNx3L4eiAoWo3OgzWCJIQnzy5ybfzomJiPJ8aKo5gyQ4k3pvHDKL0T8wtuecxoiZf1r1tQUY/P3jT6OR4yvjZvCN3mM1I6ZnS9mnyaJsa1wZC0sQ3Nt2kg4bk19mFP6nnABoPsVL2xSTpt7ku+yze4zbYffm4vi0+XjHC7Nf2vhpdoLsTDtdM57jXncz7X6Q73o6SM58BjzrxNMGQclOOGrJ4MRrNBcWPNvH/uZr86lLl9HK7C6raL4J4LsjEHpvJ18ZjsUy+NqjZ9yYNuLA20Gy3A/nYgjs+DyRMxY44SaMRm6b6Xzrp2C0a/cZzQmNk69cKSe/jnZxk3hWzh3qFgMP1LOqnHa2sQKN+b5Es8pqYk394X9KHA+WSgbnsf5l+2zzhWPWxxfHNv1xXjv8Td99Qt7qb+Awc15r/rpMZCx4lXw5vUoXNjc/M8FRRLt6/Tp43v9izrq0wAj0jaxk2f+zbO/T9OT/FJCsOPvPx5t/xKXjqlk/ksiUjqvzIi6hvnnI0JnTPcjmG0GKzUCtn+lnCidz+CTNSVNBs1oxczcuY2GcAxCXQnPczzyxNbGTTH/sdlV/bqdW+vwIp4LVRthXhX4HPUjLB/GGN9bbye4L8mV9L4IvwU53YdTpk8l898v7zH/fcYr4FVG52nj8fhsbv7VoGtRKRn2zHmT8EHyZz+auz1pdTxZ8x+LqCds6bwdUMw/xn+ngtdmsAqmo2QISudTjBLz4fKtdD66v5CTs3tN7Mt+fejxQu2wiPp8rrjauIn5Tz/lSE18vMgIOJTkyuy+II+jhcAmnAzm/6i93nl/u48gRwMuRWPE+RG58RDznwfiWtKZJHc7+9asKxEyq365X5Wb7/rk27SkLJn1RAxdHaXzlvDlxQRJ4DBEHIZcILUZLGOg0922mVmQMQ5MQ238S/eXzsd1WX1IF/FR27YMn8oNyb14POda2cZNMf/yibLUY8Y+5axqc3sja2Ka89rklexu5+MK+xEeSz/Va1zPvJ38fbpc8MjL/D6pV72m+Ibtr3Ps5/qwftOX2WPAt+a9ntsX+gfROV53qSvXdOeo1x9o/lXShgJihMWZe/kEwE3mJslFGNWAaHFy1wNB0gm85Flede884efiZ0SndN6QZB7nUclDv8JJ6BjHbQZLcjXI31rORRNxCSeTN3NzVjqf1mPKKf3wGmHidHVeWbTD5xTTsd63cVPMf/yFX63ZGY1XY5432Unfa/y+0fTN5xHDV8df26bjr8x5YT90boWct/0JFrjzduTT93n+Fr/wa/uoDfjbp+lVUP9meaP66uZ7GZ++ea+xmrUhbfG62VjfmFPE187Rwcx/IEazwTdJHgljJEBKOMP71fu5oS+RY76rkAixi6d03oKuBbu93VI8nG8nMVj1w6rNYEkOmFdZsLvcdLli42ox/6UypfNpG+4LnZ+ivwQeGif5myASb/galZvV3Q9fuHo7lm3cFPMvvwgX/JRlYVyHNf8qXrsAcFyN5rwwv6Sf8++65cy/4qE+L5tsaq7Ubfk5NHtfZkGyHaeV3vj4TLuyOdAj7xOPUeDLdv29PVeIEeyucWB7868n80ConPjUzz19LCVmYEBywticwImwlExH6bxtZ76IgITXSMj1cTjSZrBMzhXNfnPO+X6XDFjp/JwzYgK+8tHzDfjP8fRjM8q1Nm4G5v+gOIwyHg+JQ82/0TzfMe9ndY+XAw/BnDw65JyyvfkfmUja2KudBSMoxY8YCx8LZndKRu4vsR0yqe+ZINoMVmfzb3cTZ4uJ0vksbzuagGz9GIF7eNXj3jZuYv57YD1yHXpDwC0AOuV98qnHyP0nNrS4Bwcw/0z0GGA44DjQZrA6m/8u+HcyAV1iYXLqMTmldbRxE/Of4nbs9+T9sccXLV1rfDH/TPbO+K1FMurdj4A1GyzyhrzZmAOjcFPvPOceV/3m3yb3bH543e1S70cH7tHs+LsEweO8/8f/O/17iIs7Tp/jPwdO92DMvXDkXg5g/jeewO4dMO4n6dfkwCgGa80+Uvc+cwhu7nPcyDfGDQ6MxwHMP+afHUw44DiAwRpPpJk4zZjATbhJLsABONCHA5h/jJ8zfiRVn6TaM44YLDgwKn/hJtwclZvEBTf3xgHMP+Yf8w8HHAcwWExio05icBNujspN4oKbe+MA5h/j54zf3shLvP0FF4PVH1N42gdTuNkHR/gIjnAADmD+Mf+YfzjgOIDBYlIY1RjATbg5KjeJC27ujQOYf4yfM357Iy/x9hdcDFZ/TOFpH0zhZh8c4SM4wgE4gPnH/GP+4YDjAAaLSWFUYwA34eao3CQuuLk3DmD+MX7O+O2NvMTbX3AxWP0xhad9MIWbfXCEj+AIB+AA5h/zj/mHA44DGCwmhVGNAdyEm6Nyk7jg5t44gPnH+DnjtzfyEm9/wcVg9ccUnvbBFG72wRE+giMcgAOYf8w/5h8OOA5gsJgURjUGcBNujspN4oKbe+MA5h/j54zf3shLvP0FF4PVH1N42gdTuNkHR/gIjnAADnQ3/6pC/oMBHIADcAAOwAE4AAfgABwYkwNT4d+fCueLp9UA8w8EQGC/CJDD+x27o0cON48+wvQPBEBgKwRqeor532oUaAcEBkGgJgiDhEgYJ0UAbp504Ok2CIBAdwRqeor57w43FYLA2AjUBGHsyInu6AjAzaOPMP0DARDYCoGanmL+txoF2gGBQRCoCcIgIRLGSRGAmycdeLoNAiDQHYGanmL+u8NNhSAwNgI1QRg7cqI7OgJw8+gjTP9AAAS2QqCmp5j/rUaBdkBgEARqgjBIiIRxUgTg5kkHnm6DAAh0R6Cmp5j/7nBTIQiMjUBNEMaOnOiOjgDcPPoI0z8QAIGtEKjpKeZ/q1GgHRAYBIGaIAwSImGcFAG4edKBp9sgAALdEajpKea/O9xUCAJjI1AThLEjJ7qjIwA3jz7C9A8EQGArBGp6ivnfahRoBwQGQaAmCIOESBgnRQBunnTg6TYIgEB3BGp6ivnvDjcVgsDYCNQEYezIie7oCMDNo48w/QMBENgKgZqeYv63GgXaAYFBEKgJwiAhEsZJEYCbJx14ug0CINAdgZqeYv67w02FIDA2AjVBGDtyojs6AnDz6CNM/0AABLZCoKanmP+tRoF2QGAQBGqCMEiIhHFSBODmSQeeboMACHRHoKanmP/ucFMhCIyNQE0Qxo6c6I6OANw8+gjTPxAAga0QqOkp5n+rUaAdEBgEgZogDBIiYZwUAbh50oGn2yAAAt0RqOnptub/tw/Tm8vz9GWapt+/fzNdXn+Yfs90V197p0r5f1/eXabnz/b95+fpklz3JRce6Zgu05vvJZIv0/PlMl30fxOrr/H36cPrIA57QcXWLR7fGEcgsAoCNUG4vUGVN2m+qNpMzph8ejN9+C1u4a7cUTrgcpUcjJHd57t1uDlNU885Y1Bo78qlu/pk58yFc7KON8hfN7/bWB7Xn7vA4GYQGAaBmp4+zvz/9ntxAeDNf2gcxJCnr3ND0Y68Eq3wftOeLAR8HKbG9L1vJ78o8Nc5AoFxEKgJwi1R6rzILpbtIl9MgTJg4YI/fb+o8XSxcZsBWdQkhVdHoDc3o8Wn8HD1XjymgceY5RvnvnQxpt5f0o21G+t+DPy0CgLDIVDT03XMv91Nj3blghV+/rzfNcyZbCVsbmcgFY4bIZ+3kxgK1Q8xK8GnFtnm7jIy2Ro5CQKrIFAThKUNqrzUi2U9efscNvWoyTtdXMv79NrSljPlszFkynFqWAR6cnOa/ObOY4zxtjA/pI8d571s/B3r33Y0aA0EHo9ATU/XMf+lPrcY6GSR8Py9elQo3e2X92IkSg3WzvuJwZcqmf+WHYgVzIwPjCMQ6IZATRB8IyoX1ILbcN8t2Eu7p1njneaEfz9fePuWjWlb0Lbcmo1BLvK6BwTauGkf41GPmSUbTW6DKOls1lgmZfq/lRwyryaH7JyluSrzWLpotp+YBfOefBrtY4zzUl3fvo8mhhnmkoeNYyN9ysfvNUPK8QoCINCGQE1PVzT/Rhgi0bJiEJ1TQiG767o/VtTEZKh7ouvS6TtFYdauqte0LWLmDIoqK/FI85lXJV5R3zJlOAUCj0agJgg+NjEs4QLbnMtyXCZ8X4E+cjmk3knOaR2YGx5/68K2TUv6+zgteerb4Wg0BNq4Keb/Es8dmoMhX33v8sbSX1/nSHjsua7jUKbezWnJfDdNxsRH359J887e4+oIFgsN81S3vpbyWI9D2EcZr/zY6HisN5C5N4yReTVEg2MQaEegpqcrmn8TYCS6NsEv+jl7K2Dq+PPv/ou/roz9Al/4PtgJiXZR2rFwJSNT4s5O0xS2p8VVCa8RLSfcs2cTTQXFOsP6OQaBByNQEwQfWmo4zBXN8cB0uPIF8y8L6jBfVR6pSV7XZXM6XlAsbNsZpoq5cIFyMDICbdwsmUkzp8RcMr2N5qHNAMjw2M4vocmNcipzXYcb5pcuk3J9vohYvZsqpqIW5OPLjY180petS34cZMtFzerA0QAIbINATU9XN/9RF7VoPU8f1C/9qEk/k9BKpN+8fqOvKVF88+55lZ1/LbiZ9qN4ralQghWVt/2If48o+XJjWhHvQWAQBGqC4EM0xiU0KfpaaEJ8YbOrH+1WhheDYzEMUQ6ptkKzsKRtU9ZsKATtcLhLBNq4Kebf76hLZ0smv3Re7lvnNcPjjHGPzH8pv4L7ovJB4Jv3UXI5iEEfFvqQjU+XTT4lSOqL5t7kGm9BAATKCNT0dCPzL7v86hlHI9g6oaMJ3+66v/4wfVGLAzHmWvTk2cj0NTQMZQByV5oERbVtdzaUcHkjpPozb7upzlwwnAOBDRGoCYIPI2Nc1MXCxF487ytUS2ln8lWuhLuA8fvGtkUbcruPUbu82QsCbdws8zBrMOWTIZlTNgMjw+PAxEsYet4QDpfyK7gvKi+VPKKPKlaJO4ijpAXp2Oh+XK4/KqvLbT52YYc4BoF9IlDT03XNv6zqxeRrAQt2a+S6JPbnZ/84gJwLMVf358QmLNN6XBIud79ZsIjhbzH/qkxoaFxVHIDAQAjUBMGHaYxLyueS8ShN+L4+88mY1KfqkWNVJn7f0rYp4zYJwoY43i0CbdwU859uwBjNDnklQKTGU86v+3qD+Q9MfhSbnivt3Bkeu0IPyId0PpdYdHxXxkaXCTfU5Ob5K/PqHBPOgEALAjU9Xcf8a1HIPNZTEAstzMEjA36lbwVt9qx/+AlAKjItkKgyqu5gIZLc5mMwF6L3SrhmixBV362xJI3zFgRWRKAmCL5Zyb2A0zavZUHsy4oZK+eT+S5NcD3SgjR3GtrOGqAoIt7sEIE2bgrf4sdFtEYXNL3J/Nf4fROWhsdRvug2gpySZ9qD+SSdD+WZeL+osfkRbJCZezJz7k1xt96U/wTcbATUx6ZpPHQYqTa0xkY5EACBmp6uY/5LmEcTfqlQ4dl5EWb105+BUJZruX5FCZAX1KB81liYXaXwi4vBHf6XTKKTvAGB8RCoCYKPVoyLNRp2AR4ZGV+4/DiQLiN1hTfYPK984ff5c6Vtu3No8jHcDGjbTYwj4d0oCLRxU8z/8/Ql4kGwuEw61GQ2ZY6RvySf1LH8bYb3DeZftePMfDHv4txQ81hTH5d3onpHtCkmJWX+rIxN2j+fx8kYqjo6zfcSHq8gcBYEanq6ifmPEj3YrSgNgBOUUDxCAbAiXTTipYpn55WAxrswsyJNJ+JHhJpuoRAIPAiBmiD4kDLGxV9c+eiRba/cNaqvItDGzcD8V2vj4voIZOY+Mf93N56p++46qQAEzoNATU83Mf9DQ62F6r4FwCN2XIbGlOCGRqAmCD7wRxrwR7btEeBoewTauIn5335kKi2mn5h0Mv/MqxXMuQQCDQjU9BRFEcFGAAAgAElEQVTz3wAgRUDgSAjUBMH385EG/JFtewQ42h6BNm5i/rcfmQUtdjL/C1qkKAiAQAaBmp5i/jOAcQoEjoxATRCO3G/6Nj4Co3AzelQ1/MGJ138xf6MmPKeOw8dSh4PZLKb9c/X+OzL/9//jj6PrDY/nDtdNAgIBEIgQqOkp5j+CijcgcHwEaoJw/N7Tw5ERgJsjjw6xgQAI7AmBmp5i/vc0ksQKAh0QqAlCh+qpAgRuRgBu3gwdN4IACIBAhEBNTzH/EVS8AYHjI1AThOP3nh6OjADcHHl0iA0EQGBPCNT0FPO/p5EkVhDogEBNEDpUTxUgcDMCcPNm6LgRBEAABCIEanqK+Y+g4g0IHB+BmiAcv/f0cGQE4ObIo0NsIAACe0KgpqeY/z2NJLGCQAcEaoLQoXqqAIGbEYCbN0PHjSAAAiAQIVDTU8x/BBVvQOD4CNQE4fi9p4cjIwA3Rx4dYgMBENgTAjU9xfzvaSSJFQQ6IFAThA7VUwUI3IwA3LwZOm4EARAAgQiBmp5i/iOoeAMCx0egJgjH7z09HBkBuDny6BAbCIDAnhCo6Snmf08jSawg0AGBmiB0qJ4qQOBmBODmzdBxIwiAAAhECNT0FPMfQcUbEDg+AjVBOH7v6eHICMDNkUeH2EAABPaEQE1PMf97GkliBYEOCNQEoUP1VAECNyMAN2+GjhtBAARAIEKgpqeY/wgq3oDA8RGoCcLxe08PR0YAbo48OsQGAiCwJwRqenqT+VcV8h8M4AAcgANwAA7AATgAB+DAmBwoLVZuMv8vLy8T/8EADuyTA0qkGbt9jt3Rxw1uwsujc5z+wfGtOKD0tPQP889CBiN4Mg5gsJh8tpp8lrYDN+HmUs5QHs7AgTwHMP8nM3ckQj4RwMXggsGCH6PmAtyEm6Nyk7jg5t44gPnH/LO7DwccBzBYTGKjTmJwE26Oyk3igpt74wDmH+PnjN/eyEu8/QUXg9UfU3jaB1O42QdH+AiOcAAOYP4x/5h/OOA4gMFiUhjVGMBNuDkqN4kLbu6NA5h/jJ8zfnsjL/H2F1wMVn9M4WkfTOFmHxzhIzjCATiA+cf8Y/7hgOMABotJYVRjADfh5qjcJC64uTcOYP4xfs747Y28xNtfcDFY/TGFp30whZt9cISP4AgH4ADmH/OP+YcDjgMYLCaFUY0B3ISbo3KTuODm3jiA+cf4OeO3N/ISb3/BxWD1xxSe9sEUbvbBET6CIxyAA5h/zD/mHw44DmCwmBRGNQZwE26Oyk3igpt74wDmH+PnjN/eyEu8/QUXg9UfU3jaB1O42QdH+AiOcAAOYP4x/5h/OOA4gMFiUhjVGMBNuDkqN4kLbu6NA5h/jJ8zfnsjL/H2F1wMVn9M4WkfTOFmHxzhIzjCATiA+cf8Y/7hgOMABotJYVRjADfh5qjcJC64uTcOPMz8f3p7mV5999WZDgGudF6uq9ev371K7v06vf8mX194nxyrNp4+LiDrx6fpcrlMl7efbLymvUV15Azmr++nV5f2uCX+Ja8Kq8s376evufY5N+PfEmyPWHYdg/Vpero8TZ/2wjfJd5XzUd4v0Iy99HVHca7DzZfpRY230/atxljlRMs81DK3mbri+dScU/yNz2/Vv7QdG88inE3fdQ7qXHw1vf81rLcVw/Aejo84b9Gn5bwezvy/vFxLaHU9FQHVcSsUV8VFlcvdn4BnjbkWnsQ8q8WDFyR/vExkS/1I4ugwObcsqEie/rjvEdPeBksvPvXEvRfzr/IyjNXo0fbmED6m+dObm27OeMgCz/Dq+gbSbeZfz1HRXNhSz1qcM21f72vcfrrJZ7Qkmbv1PB3ma1xHyiHegw8cMBwYwvyXzLQz2KGI2V0abyq8+Xbltdm42B1vO3nLuabXQGCUuATmX8cavNdE0gIU3NNg2HX8Yb8a7rmZtAgkO/yN/OppsNyiU++k73iC3nv8jWN/s75sVH9PbppNJqPZc6O8hUHqaf7TeHNGP3cuvW+l9yp/0jnzJs7k++B05qY6V+ozsTDnDs6B7c2/nkhDw/40PRUeAdKTkSrvTHI++RdNWlF9DYkfmn8RMW2m1eLiaXr6RvVlqbFRwr9gsSDtXiNTxeQrgVy687II12uxcX0XYthmsMS4mHx0i26Xp0leKf4uzhFfR/PkXuG/4bLXD234ZCPgmjG5M37yyI/lPVi0cdM+xqP4Jjptx7mkf5oLJe6upluSQx6bkJP+U+QCZ6N4w7rMsctJ9WjR/zaPl0bnljz2ehcGJv4Z9pJTjWOU5m/EI1XHtRy+qw9+jKJ2qXMXcxpjlufv9ubfJkx+Qg9FbB6w7PaLMBZFW4Qlk5z5dudt6edAxRzIqwjur5+s6b/RUKv4GsRK+nu5tlDQ/TULqpnIWgw2/aQhgzsJmOHYgDi1GSwxGOEC1pyT3IzGu5KPUbkIj2BhcS1XGvhv2vF1+jyx5yS3oxjUmF27vo9xLeO8n/jbuCnmXz75tf3THAn56vtdnEdmXPD33I9nPNdpfQ54/vW79/Y7MhnOWr57Dsd1CWfjXDT1xOd69qdQV2lBLjkb9NnMufkx0ngXx1D1v3LfquNY6DdtsjAYnAMPNv/vp6cg+asGVYvIq+lV+MXegrCUxXy5SESiLIKlhOa723czq/18eZl0/HrBUf9EQdejyzUIn4o9wPr+yQvROyKGbQbLmI3USES5Egqfzps6lz2Wpm69S1k05IZ7i/iv4ykY+Up8Jhcb8ivsL8erTPxt3BTzn45Z2fyW54s1Nc7wXAx8OYYcZ9O+xHUNZf5L847OufYxetFzffijG+HYGDwES68lYRmOwQUOhBx4jPnXiS+Py1hxk9317OvT9Onjk/7VAiWS3nTkkl4JYSoqZtC9WQgfO0qPw3sDIxLVGZ4P728zODqOgrFpNRvSl2bBK4kwRmUVoxIm2Z6O2wxWajasqOq8zuRA6fyMezavGhapi/mv20pNk43bbizkfknk6qdusz4wwazF9zZuivmf87BksEvn1+qHqTfJITcnhvOP4lKOs+m5pK6mezbiaWneKWhCbiwk1/3jv2nsOR+QluH9unwG373hu735V0n/9pPe3fYmvvzznam5VeKQ3heJQkls9K8IJcJa+ORABlGJzqu3T/Z5QiWwZkJJY1DltUAVDL3UJ6/XymoBbNjRd6LY8pNxRVxIWhkXXl+mNoOVmg3LocKEbj7On5uxPN6mbr3zf2URsIj/S8y/7DJeaT8fP/m0Fi5t3Nyp+beLSK/9ki+p0Vf8Ss+l+Zhez92zEU9L805BK3T/g3lU8Eh9QMwxzH+Mx0Zjy8bHrjcOtzf/gcg5E6+FIGPqM5OvEgN3n6orMfCz67a9rOFO7o0SSK6p1yCOVJzUPcaEiFg3JF5JEJNk8uYmWbQk5cLvJ5REMtv/tB7e7zqZI/7eOJZtBsuYjSgPJQ+CXHHxFCZ6dz0bq5nQWxYBLfw3bdk6A3Ohz0fx2cVHWiYbY0Ouc1+3nGrjppj/VDNzhtiMX07T69zsMe6pYQ/rDK/l4k7PheVVPen10rmwzZWOZR5N80DnXH2MzPyXlsnFqfrfUi53L+fW5zoYj4jxGObfCoM3u/JI0Jw0c3NvhM6YXiUCGROuBSgjDiVhUvF8fDK/jhOYfxWfMTxGbN2vJ+QMTyp20ftCnFGZoO+Ni4V0IeQJF2IU1Ftqj/PdDIsfg33g3mawhP9BTulcKnwBPjLXy3GY53yhjlo+a06bPFB56xfJpi9uIXNnrHsb7z3F28ZNMf/xF37N3JKZG+Q7VtcWezV+36SXhnfCw09vg9h0W5JbLUY+rqtm/qNPyW+Ku5B7xbpU/NKX4F6dZ7UxyvU7uD9sr3V+DO/h+LRz3J40b81YhzL/egdGPe7y9r3+i71qknaTsk3WmhHQAj8T8YqIXDUL9pOFmbkX8xOaiIIwFUSm1o/uA97Sz0Kc3WOhnaFFt81gidnweRAb6iQXhjHUogWfnL7MNEZMSea7R2LUyIlkfDfK6TZuivk33xNT42v+B+Y6iVfPO7N5I+njyubffaHVxuu5Jpz9GuhGek7yUWJOr9vzAbd9/XLPeq/ZeVk0IYgp/jlg0wc/fjKO8YJB5eKmc2nCHbRgPd6A7brYbm/+rYjKF+m08M4Ez3daXw/MtyR6eF9WIHSdr6b3/1v+TkBsVMr3KJEJdipUvLZ932Z5ImknrIonaGdFURHM2mPz+HPPubBoM1ip2dgLRgVTtGLukT/9uNHGzcD8M67BgqHfOCzntMm7aMEh5v/eMWJja5AxfiS/aHt5Tprv902Ff38qnC+ebhbnexP+KPdrAVx3AaB3XYLF0y0k4Z7ziEtbDmP+yYntc6KNm5j/IbmZfnLSxfzvVYe2z50hOXEUH7fTfig9Lf3D/O90UEl0xPVWDrQZrL1Ouuz838qLEe5r4ybmf4SxuhpDF/OPzl/FGQ/DJyMFDmD+C8CQVAjrGTnQbLDIGyaVjTkwCjf945/Bc+jqMdNv/s1+vyA9/376ujFWi7XLPY6bxH55Nb37H+k5+/7a9yRG7zPxoWEn5gDm/8SDv3iCAKvDi+UoBgtusvhOOQA34UTKCd7DCThwGwcw/xjawxtaxKFdHDBY7VjBq22xgpvb4g2/wRsOHJcDmH/MP+YfDjgOYLCOK/Z7n8jhJtzcO4eJHw6PwgHMP8bPGb9RSEkcjxNIDNbjsIf3dezhZh0f+AM+cAAOtHIA84/5x/zDAccBDBaTR+vksXU5uAk3t+Yc7cG5o3IA84/xc8bvqCSnX+0CjsFqxwpebYsV3NwWb/gN3nDguBzA/GP+Mf9wwHEAg3Vcsd/7RA434ebeOUz8cHgUDmD+MX7O+I1CSuJ4nEBisB6HPbyvYw836/jAH/CBA3CglQOYf8w/5h8OOA5gsJg8WiePrcvBTbi5NedoD84dlQOYf4yfM35HJTn9ahdwDFY7VvBqW6zg5rZ4w2/whgPH5QDmH/OP+YcDjgMYrOOK/d4ncrgJN/fOYeKHw6NwAPOP8XPGbxRSEsfjBBKD9Tjs4X0de7hZxwf+gA8cgAOtHMD8Y/4x/3DAcQCDxeTROnlsXQ5uws2tOUd7cO6oHOhu/lWF/AcDOAAH4AAcgANwAA7AATgwJgemwr8/Fc4XT6sB5h8IgMB+ESCH9zt2R48cbh59hOkfCIDAVgjU9BTzv9Uo0A4IDIJATRAGCZEwTooA3DzpwNNtEACB7gjU9BTz3x1uKgSBsRGoCcLYkRPd0RGAm0cfYfoHAiCwFQI1PcX8bzUKtAMCgyBQE4RBQiSMkyIAN0868HQbBECgOwI1PcX8d4ebCkFgbARqgjB25ER3dATg5tFHmP6BAAhshUBNTzH/W40C7YDAIAjUBGGQEAnjpAjAzZMOPN0GARDojkBNTzH/3eGmQhAYG4GaIIwdOdEdHQG4efQRpn8gAAJbIVDTU8z/VqNAOyAwCAI1QRgkRMI4KQJw86QDT7dBAAS6I1DTU8x/d7ipEATGRqAmCGNHTnRHRwBuHn2E6R8IgMBWCNT0FPO/1SjQDggMgkBNEAYJkTBOigDcPOnA020QAIHuCNT0FPPfHW4qBIGxEagJwtiRE93REYCbRx9h+gcCILAVAjU9xfxvNQq0AwKDIFAThEFCJIyTIgA3TzrwdBsEQKA7AjU9xfx3h5sKQWBsBGqCMHbkRHd0BODm0UeY/oEACGyFQE1PMf9bjQLtgMAgCNQEYZAQCeOkCMDNkw483QYBEOiOQE1PMf/d4aZCEBgbgZogjB050R0dAbh59BGmfyAAAlshUNNTzP9Wo0A7IDAIAjVBGCREwjgpAnDzpANPt0EABLojUNPTVc3/l3eX6c33v886VDofFvz9+zfJvb9PH17n6wvvC49VO5d3X8JT5ePPz9PlEpY37T1/Lt/SdOW3D9Oby7K4m+oNCimsLq8/THOkg0IcgoBFoCYIt4P0ZXq+PE+N2XZ7M73ulHxXOR/lfa8GqOcWBNbh5jRNarxb54JbAu9yj8qhy1SdczRv30wffvMNav3XPB4k/26Z8+w9OhdVX9L5TF+P++0R4AgEQCCHQE1PH2L+p+mayKnruUQ3hrxJxFvEIhScRGz0wkGMQfCaW8zkQDfnSv0o33HrlZYF1a11c9+xEKgJwi09Hc58XO2EysvQKBk9atKVq3VT4B4EenNzmuycoTT8iOY/O88ZPlcXEfcMUvXeW+Y8NUbhfG/HLJmT9QIuPVeNhYsgcG4Eanq6mfkvmWm30g+F2e7SeFNhd+cCE+7uU2IQmvhcmey5YPJX9weiomMN3mv6ZEW2Tiwdf9ivevH7rur4gj7dVxt3HxiBmiAs7bZbdOodyR3zb+/xLx24Qcv35KbZZDKmUmv6Vlp8M7Y3mPYsb2+o5+aY4xu7zXnZ+dYsCh6zqIn7yTsQ2AMCNT1dx/xrQQoN+/P0XHgESAOoyjthNgm+bIc9GYalRliVF7OvYgkXFK+fp+fXqi9LjU15B8QZpiTs9O1SIVX1IowpirxPEagJgi8rBsLuwskC2uWpL6mPsiYkKaPflvMiLb2U/+Z+rx/a8Enckt9pI/K+OX65gdc1EGjjpn2MR2my1no/15T07zHmX3LIvF7cp9lxTvmYpXx8PZoLA57q/BB+q1fFcX3d4+HbXGO00jrzua3jnMUW7vSn9UzTlDX/e3l8K9MfToHAAxCo6ek65t92Mm9yReDySIigieAVRTsQwbimvADFZey7mVAGHw3/9sWa/hsNtaq7aDgCcS+ZKRuiMzDFunzPbjNL/n6OzoFATRA8AiZPY/Ngzklu+rKBGYtOFt4Ehs0bn3zZJfw3Nfjc8nXbc8Vcu3Y9Hxtn+yPQxk3hW/JsuNbzvKksziP9uxDUKDkUbxylsXz5Xr6vJeV9H8x86N/rR1/CjajsPGjq8fwPQlrzsDDnyZzuN/imyZyLcQlD0xjl5jytHeX7wjo4BoGzI1DT0w3M/4fpOUjiqkG1q/034Rd7C8meCqgMsj4f7obkjoN41H06JjmnxVTtnLyZPnyvvgR8m9BU+ynBLnge1fVL4nR1BAcF8Q1KcAgCU00QPDx5ox/lii9svlC5NFdWWQQUjHzWJJkOmNwKDFbYL443RaCNm2L+0zEzY59bnJbmi3U7l8uhcozyXbg4/sTIpzxO3+sOJfes20lXe2nO0+dn2lCO0ZQvbbqp+9JxdyFwAAIgECBQ09P1zL8WJXlcxk7IOSPuzj1PXz4/61/4UULtBdDcG+9i5AXAGeTiDp+dNCIDbUTIfIcgFJXwfPgxattioCSEwbgEh7atKK7gsjsUHAsxKMyv1uEq4+CkCNQEwUNiOBnnnZiuDP+yJsTXVj2yWuFzvlT6Cv/1babMrC67sRD+SoqYrfjTjVLbnN8CgTZulnlYMvml8+v2KZ9DYm7nG0u58sm5NM/S97pDyT3rdtLVXprz9PnZvJTLU8nvkvFXTam+hfO0a54DEACBBIGanq5j/pUgvfsyxSbe7LDHk7JJ9tRg5O4LPzLMfetfi7sSGNt2goF/q64HQqSE6c27Z/vMvxIWY2zSGFQFJXHzlfujtrJGpPXCo7ZgCT8hCGL3rdmjpG+z65wAgWlatPOf5ubssQNBVHFvtrsnFwuv+h6zsJ61E93iTUGYu1ER9yZnKjLPEMunDrV8cnVysBUCtckqiqHANz0PZLS0dD6qs/ubmgnPcTpXPjmX9jt9r/uQ3NO9X/kKS3OePj/LszRPTczXNUSVw/znR4CzIBAjUNPTdcy/bT8y0HaiD81/XhSm2aLBfPnH7zZG9aq2VN0iLuo4I/4OkrCsPFKkXuV+tbeQ+fsAOtYl5iZsxzUuByJ0wXcM5FL0mpsgogLRm5L4RoV4c3oEaoLgwTEcDfNVXSvlbHFR4Cv0Ryo37Cd+/Uy/VG9zJtUA3aZoiM2/tIxUwevDEGjjpuz8pyYwNZS+GzlN91fXOjI8q3I8+kQqVz45F/FYcBBeSz+Se+T02q+FOS8/d4Yx2pwN5uBiqDJnFwtwAQRAQBCo6el25t9GY4RAHqNJRcsUmpl7u/NtRFSJRv4+fbcSoNqkHgrU52fz6ziB+VfxGcNjxElMiltcCKpXX8txzvuXr0xjVetLdJsR0OpEE5XnzVkRqAmCx0T4HxgsPfEWPpJPTYmvKDlS9QZ1JlfDt8v4L3daIxH9sSTTF7eQaY5V6uR1KwTauCmmN/7Cr5lb8nNDk/mv8fsmAAzvYk3+ffrwTr7gK/2QmHPlk3Mpd9P3Os6E7zfFfstNql3pi7/fjEu80aXHQ8y+xn1NTfCxcAQCZ0Kgpqebm3+d9GrX790H/Rd7lbl2k7IdlZo5vmoItBjK4qLwKqIjLAjMv5zyzwMXzI4vWDyq9aN4060XtIDOhffW6rjvuAjUBMH3WkyHeZVFcGxkfOlFO//Bbf0PZff3i9OXmcZUNKLYv/6BUmMGgTZuBqY5Gsuy/ul559pGyibmX2KXuSk0vZJzITDJudTsp+/trc5wNy60wxbvOc7NeTqW1x+mL+ov0ct3/MI52OLurkmZmTdgg+ueseHe8yFQ09N1zL9LZiNsWngrH/Pr64EYiICE9+WEwZwLxdMKa03klVgGbWk6qHjtOd9meSJpp5AS7iS+9psXlRTMFt1E4VMiUBMED0hiOvyFwY/E/P8+eJyEl0OgjZtioHtodC4Kzt2OwHzOE/N/d0bm5u7bA+VOEDg8AjU9Xcf8Hx7SBR3UOzPrLgC6ieuCblF0vwjUBMH3CvPvseBoKwTauIn532o8bmonmfO6zE96Q3HdefSmvnITCAyMQE1PMf8DDxyhgcAaCNQEwbeH+fdYcLQVAm3cxPxvNR492uli/nsEQh0gcDIEanqK+T8ZGeguCNQEAXRA4JEIjMJN//inPJtvX1//xT+3HjybPnuU9JEgXmlbm/Ewdjn+9/8+/Tc5jl7Zcb8CKZdBYEgEanqK+R9yyAgKBNZDoCYI67VKzSBwHQG4eR0jSoAACIBACwI1PcX8tyBIGRA4EAI1QThQN+nKDhGAmzscNEIGARAYEoGanmL+hxwyggKB9RCoCcJ6rVIzCFxHAG5ex4gSIAACINCCQE1PMf8tCFIGBA6EQE0QDtRNurJDBODmDgeNkEEABIZEoKanmP8hh4ygQGA9BGqCsF6r1AwC1xGAm9cxogQIgAAItCBQ01PMfwuClAGBAyFQE4QDdZOu7BABuLnDQSNkEACBIRGo6Snmf8ghIygQWA+BmiCs1yo1g8B1BODmdYwoAQIgAAItCNT0FPPfgiBlQOBACNQE4UDdpCs7RABu7nDQCBkEQGBIBGp6ivkfcsgICgTWQ6AmCOu1Ss0gcB0BuHkdI0qAAAiAQAsCNT3F/LcgSBkQOBACNUE4UDfpyg4RgJs7HDRCBgEQGBKBmp5i/occMoICgfUQqAnCeq1SMwhcRwBuXseIEiAAAiDQgkBNTzH/LQhSBgQOhEBNEA7UTbqyQwTg5g4HjZBBAASGRKCmp5j/IYeMoEBgPQRqgrBeq9QMAtcRgJvXMaIECIAACLQgUNPTm8y/qpD/YAAH4AAcgANwAA7AATgAB8bkQGmRcJP5f3l5mfgPBnBgnxxQIs3Y7XPsjj5ucBNeHp3j9A+Ob8UBpaelf5h/FjIYwZNxAIPF5LPV5LO0HbgJN5dyhvJwBg7kOYD5P5m5IxHyiQAuBhcMFvwYNRfgJtwclZvEBTf3xgHMP+af3X044DiAwWISG3USg5twc1RuEhfc3BsHMP8YP2f89kZe4u0vuBis/pjC0z6Yws0+OMJHcIQDcADzj/nH/MMBxwEMFpPCqMYAbsLNUblJXHBzbxzA/GP8nPHbG3mJt7/gYrD6YwpP+2AKN/vgCB/BEQ7AAcw/5h/zDwccBzBYTAqjGgO4CTdH5SZxwc29cQDzj/Fzxm9v5CXe/oKLweqPKTztgync7IMjfARHOAAHMP+Yf8w/HHAcwGAxKYxqDOAm3ByVm8QFN/fGAcw/xs8Zv72Rl3j7Cy4Gqz+m8LQPpnCzD47wERzhABzA/GP+Mf9wwHEAg8WkMKoxgJtwc1RuEhfc3BsHMP8YP2f89kZe4u0vuBis/pjC0z6Yws0+OMJHcIQDcADzj/nH/MMBxwEMFpPCqMYAbsLNUblJXHBzbxzA/GP8nPHbG3mJt7/gYrD6YwpP+2AKN/vgCB/BEQ7AAcw/5h/zDwccBzBYTAqjGgO4CTdH5SZxwc29ceBh5v/T28v06ruvznQIcKXzcl29fv3uVXLv1+n9N/n60vsubz/N2gzL3HT86/vp1eV6+zfV7Yzpp+npcpmePkqSpe/lPK/34Xxu/NYxWIqrT9Mnx+UtMe6TJ0qXLhf/3+fhln05d1vrcPNlevn4NK0yLzyC73ouejW9/3V7rpgcWZjnCvsgr9JxUHP95Zv309dHYEmb/b0SmA6D6XDm/+Xl2mStrufEzSwAUvEIjeB80dBDIEvx9Kg7rCODixb6hWJL8g2TfCE3RznubbD05K0n90fxNJM3S3MgNYfWsLAACPVp/ePe3Hx5sXOG4ucam0JLedaj/IPMv87zxRiq3Ax1weRqOhYtG4Kj6CdxrK8DYNwH4yHMf7qrFu0EpMJsJ2JvKvxu3Oy+ZMfgajtuByIUpDrQt4levc48ufMmBmG8BUvuyXPsZeppsBw3tVluz6lSbLedz+fNbXV53mgtWWx2/P33tn/G+3ty02wymU2kQ43lQ8y/yrHchtwNfM9pBZtcbFj1WBhTR8Sj7c2/3TXzRv1peio8AqQnOGv2zWTX9nhPfmJU93YSKEeisujpCSW7mPB9iMqkRkILnixsVNwFE6PKJYucfP9vEGLXT+49C6ZtBku4GOycpov0kDu5CT287o5NvU4bopzItzl7dLA1b6RNiS26L3y8Ls/9QxlGwWLw1zZu2sd41I5y45g+bCyT+CIuZ3mZmVYTPwIAACAASURBVL90OZknpM+ZciuObX4DLJ+v6a7+TFel30m8aoz4pC2vRTMME+y4Dm45Dmxv/i0xVTJHYqfPi2DkB0t2++W+omhnBUTV3Xn3UbWTM94fnyKh0nG6ct4wOTGzAu7e20lB+hl+PO3KuARX/dpW7HNE4lyes3vDpc1gmTy9RLwz5zxnAzyy+Rhcd5oQ5mda37xNowcB9xfljW3f5l6Ux/pcUK/LNXuPbWeei/M+7W38R463jZti/i+xNlfGtDiPpOPe9f3X6f3b4Fn2lFMzXtp5w80jvp+eh/McWX88TVw+BsmBXCxpTktZebV9jBb95lp+gSH38br+OIPx0TB+sPl/Pz0FYlZNcC2Or6ZX4Rd79bnQMBiCZsXciqvbVXS78rJrIq/z+kqDXo03nCi0kEu9OYEz58Q46XoDXHT76eTg6i+JL8laGjfOl7nRZrDyk3iWt4qnEf/LbafjEudxrk1zToxHtv1i3tg4sqYwzsc4LtNmtFhwudjet7hO7mvBo42bwrd08VYe05hnjxqLJL4cL5M8ysadu29Vfqp8SLFWGOby1fxYRyl3dH+yddkxTefEVfv1KB7QbosWUOZ+njzG/GuBUmZbGWIjenVT/jR9+vikPylQAiEmWXbEZfI3hCiJUQNYyigsEJia+dfXogVGbP59H1RcofCHx2HMRkzjvvp75+fDezlGLNo40GawClxMzInDvHR+NnlntMDtAubaDM8tzRuLRyG2srFKdpRnfWjD2WHD/dFzqDVc2rgp5l/01o9HdkxfXqbS+Vosfa4Z/oZzn5sXcryMzoXc93180YvdnBkPynTlnIoj114hvqgPEpPgkKvHllH3LZib+4yPxMcreB6PA9ubf5XEbz9pwXVCV/n5ztTUxubf7iQ4g3DnDsFCgSmZfz2ZhEIVCV7OpITnwuOQcAUxtQuHFCeSNcSO41Y+tBmsAhcjngeYl85HJsTUGWpCbMpybYbnluaNja8QW9y21ZnVf843wCzChvOKv23c3In5n30ilfA3x8voXMj9gB97M/8Wh6vGXvU9nFPJj+ZFc6v2Uy7IoxPwa3vzb0GNTLwWtXBHv/zxYHSfqkuLh9/lSa/Pd+Dl8Z7kVS0glgpMtnxGlHX/JMZE5DUe8bnUeOiktBjNTb5qr7JjcgISI1r9RKvNYBmOh0ZdjYHOtdwEHfG/EGumTJwHmbxKfhY4Lm/bKeZNeD3NnzgfzWNLfOHw0XnWxk0x/1fGNNDFLG+C62v0e54rOc7JnBFyVc4l5W28Zr5L+17IuS59NHHk56V4Tp9rhMnpq18CFm0JN/m6xL4mLtS9Rt5QZz9ejWH+I+ESUy4iF3dWCXVsOkLxUWKSv6+FNFo4FwlMrj0jaD5GK3AurpxoJ+dmhkXqyBgQVTZnuBBHdkZu4ECbwRI+BiZjtpMZ5G3G2M/yUZcJ6rM54I2BaTM2Gck5e48vI3Fm8kawkXaCHDIGyuvII8zhDB+J98SvbdwU8x8/npWOaYhv0/jW+H3DmKTxmPfB3KZ56Tmo403OmXuCnJFd9I03g1Qcfr6TvJfcm8fn8jPpTzgm8XE4x0v9vMYYgQd4LOPAUOZfi7D+ycD3+i/2qmchU1GZm3/fYS2Gi8y7v1cRp1Z3iVjZe8RQ6Gf+zfcVzPcbVHuJ0dcTR+ZcVIcS0MTo2Akn2/4Nk1Gpf5yPOXJ0PNoMlnBRJnizYHeTesq/xklecdk9/2wfDVxk/lW7jXnjxlFii+6LTVcUV/Z7POfiiMMuHeeV37dxUzgguiucisc07IMe32vzxv/f3hnmOI6qa/jsKQs6Or/ulaa713AX0Jqo99Ej1Wxj1FKr9nCk0Ui9gfrlK8BgwPAFO5hg84zUSiqx8cfDy8trkqqpHP7tOmD1/umPH+H/pd7q0meaeM3eNJh2XvOnPuNP3w3bAo8I5pwdp4SXaPb58fPHkud4ERoo00D78B/tTvgLayo86Pe9XTn1s7oh8M+zBrp+9HYdfBO1HyMGC3m4U1QuIGVy+euUt1M2YEF7mCK7+5GuA33seK8sYNmFfYdmd9T0bJ/E8xOBSjy+t/oHqqdMm174H4jNqzW73nir5xF2zX91H7n+BfweT3CZqX34vyJ8HSBa3wDUM1dMDVOzGigLWBfSHuHfLQZWA70+lmmT8P+a8TOfXsuf1G33WX1T4W3+vaZv2+umTpj1rgHC/xVvRujTaQJNbwZRFrAI/72N2wj1lGmT8N+HFi7kEaynrKcX1ADh/4KD2of5c+d/xnEoDljMGxbExhroRZvZr5z+9u/ld1b8r5R2snN91rrP6KPUzPrfuwYI/40XsN4FQX1jm1YvAQsdjq3D1PijTTSR0gWvoQs0sF0DhH/CPzuYaMBpgIC13URZeNowQ5ttOKNnOKOB62uA8E/wc8GPCX/9Cf9ojAlYaOCRRl71PtpEm6/SHtdFe1fTAOGf8E/4RwNOAwQsFrleFzm0iTZ71SZ1oc2zaYDwT/Bzwe9s4qXe+oZLwKrPFJ3WYYo263BEj3BEA2iA8E/4J/yjAacBAhaLQq/BAG2izV61SV1o82waIPwT/FzwO5t4qbe+4RKw6jNFp3WYos06HNEjHNEAGiD8E/4J/2jAaYCAxaLQazBAm2izV21SF9o8mwYI/wQ/F/zOJl7qrW+4BKz6TNFpHaZosw5H9AhHNIAGCP+Ef8I/GnAaIGCxKPQaDNAm2uxVm9SFNs+mAcI/wc8Fv7OJl3rrGy4Bqz5TdFqHKdqswxE9whENoAHCP+Gf8I8GnAYIWCwKvQYDtIk2e9UmdaHNs2mA8E/wc8HvbOKl3vqGS8CqzxSd1mGKNutwRI9wRANooHr4Vw3yDwZoAA2gATSABtAAGkADaKBPDUyZ//6VeT37shpg/oMABM5LgDl83rG7euVo8+ojTP8gAIFWBCQ/Jfy3GgWuA4FOCEiG0EmJlDEoAbQ56MDTbQhAoDoByU8J/9Vx0yAE+iYgGULflVPd1QmgzauPMP2DAARaEZD8lPDfahS4DgQ6ISAZQiclUsagBNDmoANPtyEAgeoEJD8l/FfHTYMQ6JuAZAh9V051VyeANq8+wvQPAhBoRUDyU8J/q1HgOhDohIBkCJ2USBmDEkCbgw483YYABKoTkPyU8F8dNw1CoG8CkiH0XTnVXZ0A2rz6CNM/CECgFQHJTwn/rUaB60CgEwKSIXRSImUMSgBtDjrwdBsCEKhOQPJTwn913DQIgb4JSIbQd+VUd3UCaPPqI0z/IACBVgQkPyX8txoFrgOBTghIhtBJiZQxKAG0OejA020IQKA6AclPCf/VcdMgBPomIBlC35VT3dUJoM2rjzD9gwAEWhGQ/JTw32oUuA4EOiEgGUInJVLGoATQ5qADT7chAIHqBCQ/JfxXx02DEOibgGQIfVdOdVcngDavPsL0DwIQaEVA8lPCf6tR4DoQ6ISAZAidlEgZgxJAm4MOPN2GAASqE5D8lPBfHTcNQqBvApIh9F051V2dANq8+gjTPwhAoBUByU8J/61GgetAoBMCkiEcXeL7t9v05c9fR1+G9k9K4JXaPCkyyoYABCCQJCD56aHhP7fQ5173q//155coJPya3j7vCQ7qvC/T2z/TpK57u92nd/9Cpc//eZu+3PZcP77A+3S/3ab7z/h1foZAGwKSIeyvQOn68dx6OPfneXa7qbl6m26f3yZuFfaPytnOPEab0zT9vE+3b7uc/2wIN9e7a11UPO0cVY8RW7V+M3c3DwUnQKAqAclPXxL+p+lRAFbvm8AekjA3ALHRhMfEPy3hX7+jwsXmQJGrJ75W4c864DwOSoWtcRgENhGQDGFTQ/PBeqHXQeCxpuXwH83VaZ7vm+frnl5wTg8EamtzshpKBNQe+vvqGvTcjYL745riG32znsfrsjzXH1+FIyAAgecISH7aLPyb3YV5N8/fMbDPfQOad2mWUCGcp4JBvFto2xQfHwcVi32fQdqz048YY5oLrx5PQDKErVd3OtY7gY/nlDu+9EJ6bqc2Akob4LgzEaipTbPJ5H3q668xZ4JyWK0VN7VS859NrsNGjoYhUEJA8tNjwn/8keDtPt2l7/rOYd90xuz21ftesGlv/9dsBIOMbzqCHUrbj3f9dSX1EWlQgzo3OL5kKDkGAs8TkAxhad3s5t1/zrvv9kY6F6BSi//SmHtG+HcoeJIgUKbN+Ws86mtmkQcHHuu1r3QX70x7bx/6VF/bzp94HXCfgs+758lPvI8pL72ptXHe29Iy81/1PTcm9lQeIQCBYwhIfnpM+J/7kV7orbmkO2t3+234z5p2bDbRIuB/XzgwIH3chp1EdZ1USNfXD41N1+qOtaEpdy3FIfdemg2vQqAGAckQlvZTYcS8ZufmcqwXxoIX1z+kPWF9nH0lnFP2VR6vSqBMm1Zv0e+EaE9Oe6rWUe7G9TCY8xrg1oRpmuZ1agnEdp49/tSsbpmmtqUO27qtx+cozHt92tzPBN/0DYa9Fo8QgMCRBCQ/bRD+36a7Z36iGczB/Iv/i736tbUxrsxcHeddR/+C1/yzHzjE6ydGIX18zuyMSRpDzR1jL5IzX/s+jxA4hoBkCMsV0wu+ng/+PLMnxDfj9vXo0Z+L0VurH/W1Vjulq8N44UIEyrRpw78fUBUE46mpm9PVetGCWeZmJJxD6Xl2fHnqujE/ddV0PWHNYXWabbKteZxSfhE2wU8QgMABBCQ/PS78zzvj5q/rzEHY++gz+EsB+vX79P7zrv/CTxgQUiE5YVxC+NfGpXYl5psL9Zd/Sv9z5wYnGINc75r4i4//PDh5/iHVr9RxvAaBugQkQ1iulNF4LuTnXl8a1M/CuR296X40c2P1VTn3Pk+uSqBMmzb8F2wKzaBeEf6zgTmYK5l5dvgAJ9ZQfc1MPUHNtjhz7C0X/NVh6jzCvwXGIwSaEpD89Jjwryb8t3f9pzX9XRhlhv7PdqcmDtFxQFgF8JSh6GAf/WKwNR19Y3Cf7v4nCoVDsLq2Pi9jkMHOE+G/EDGHNSYgGcJSSkbjyRCQD2NLe+ZZPLfj9+3O4+4/ybtukFdORKBMm3m95UJ+7vUj0Vw6/Nv11q6xOZCptTp3LK9DAAJVCUh+ekz4n8sPFnodGsK/k58zx+A81ZY2mmWXZ/W+PcY3osB05p1E9/6GXfegHTsuuWDvB6bcMbYNdWzqY1f7Po8QOIaAZAjLFY2Ww5v1acrNWb3D9/Tf+Y/n6VINz8YgUKZNG/5j/8x77ivCf25OhHPIXzNajrFhFW+82Ztved6bmkt+gVr3NfG7AC17yrUgMCoByU/bhf+ZvjYD9/WfJdD7g7MO975RKeNJn+e3YT9VUCbmrulMqLQN1WLm2PlmxjdPvcBENxixiboakzcV7l2eQOAwApIhLBedF3j/BnXe7fM1747X8+HxvFzPbdfCrq/leWfz9AIEyrRpw3/4C7/G59MaLAr/kr53sU3czK6uYeZZck7tumb5SYrXen0qmPeFc92uwa/oWzkFjoTAdQlIfto8/GsTVuH/25v7E5ixAUkBQRu8C/Fm0Fy4dzcV6us/ZlfIXE8tCN6ukDJgF9IfD3y2nvkGwP3+QlCXd73EJbJtJo7lJQjUJCAZwnIdG0psGDBfqcsu5IWBQNT9HIzcfPLmc+wRS508uxKBMm3a8G9+T2zRSzr4Kz56HQj8OUFtFcwTx2x+ab4BcFqOP62w82xzw8+foPsbM7P1CPM+Xvdc38K/fhd/Yv98wbQAAQhsISD56THh3y3ifgDPhwdtzF4YtwFBv+4Zy2Ly/nf7YzNd0KwNfzG0bWFCnZe/znLFwmdJ0y08l8Mg8CQByRCWpm0IWF6p8czO7Rpt0cb1CJRp0wv/10PQtEfrzbR685653nQouRgEVgQkPz0m/K9KuMALerejxg1APXO9AFW68AICkiEs5RyjUwLBQphnawJl2iT8r8ntfWX+ZMJ9KlJn3uubCm9Db291nAcBCOwnIPkp4X8/V86EwCkJSIawdKhOCFjaM88I/zERfvYJlGmT8O8zq/v8mHlft0ZagwAESghIfkr4LyHIMRC4EAHJEC7UTbpyQgK9aFPdpCa/Zvr5P5nX36ZfB/HuqZaDukizEIDAAQQkPyX8HwCcJiHQMwHJEHqum9quTwBtXn+M6SEEINCGgOSnhP82Y8BVINANAckQuimSQoYkgDaHHHY6DQEIHEBA8lPC/wHAaRICPROQDKHnuqnt+gTQ5vXHmB5CAAJtCEh+SvhvMwZcBQLdEJAMoZsiKWRIAmhzyGGn0xCAwAEEJD8l/B8AnCYh0DMByRB6rpvark8AbV5/jOkhBCDQhoDkp4T/NmPAVSDQDQHJELopkkKGJIA2hxx2Og0BCBxAQPJTwv8BwGkSAj0TkAyh57qp7foE0Ob1x5geQgACbQhIfkr4bzMGXAUC3RCQDKGbIilkSAJoc8hhp9MQgMABBCQ/JfwfAJwmIdAzAckQeq6b2q5PAG1ef4zpIQQg0IaA5KeE/zZjwFUg0A0ByRC6KZJChiSANoccdjoNAQgcQEDyU8L/AcBpEgI9E5AMoee6qe36BNDm9ceYHkIAAm0ISH5K+G8zBlwFAt0QkAyhmyIpZEgCaHPIYafTEIDAAQQkPyX8HwCcJiHQMwHJEHqum9quTwBtXn+M6SEEINCGgOSnu8K/apB/MEADaAANoAE0gAbQABpAA31qIHebsSv8f3x8TPyDARo4pwaUSTN25xy7q48b2kSXV9c4/UPjrTSg/DT3H+GfGxmC4GAaIGCx+LRafLZeB22iza2a4Xg0gwbSGiD8DxbumAjpiQAXw4WAhT56nQtoE232qk3qQptn0wDhn/DP7j4acBogYLGI9bqIoU202as2qQttnk0DhH+Cnwt+ZxMv9dY3XAJWfabotA5TtFmHI3qEIxpAA4R/wj/hHw04DRCwWBR6DQZoE232qk3qQptn0wDhn+Dngt/ZxEu99Q2XgFWfKTqtwxRt1uGIHuGIBtAA4Z/wT/hHA04DBCwWhV6DAdpEm71qk7rQ5tk0QPgn+LngdzbxUm99wyVg1WeKTuswRZt1OKJHOKIBNED4J/wT/tGA0wABi0Wh12CANtFmr9qkLrR5Ng0Q/gl+LvidTbzUW99wCVj1maLTOkzRZh2O6BGOaAANEP4J/4R/NOA0QMBiUeg1GKBNtNmrNqkLbZ5NA4R/gp8LfmcTL/XWN1wCVn2m6LQOU7RZhyN6hCMaQAOEf8I/4R8NOA0QsFgUeg0GaBNt9qpN6kKbZ9MA4Z/g54Lf2cRLvfUNl4BVnyk6rcMUbdbhiB7hiAbQAOGf8E/4RwNOAwQsFoVegwHaRJu9apO60ObZNPCy8P/j99v06Y+/Xeiw4HKv2/fV499/fIrO/Xv6/lu6PXOeef92u03yv0/T9/+WiFi1Z45V9d5uX6cfewLkf79Pn26ZuvV7uXZ/TF9vt+nrXyW1coyvHZ7LejgmYCm95rScrkfN8dvvP1b+8Mz4mbm6eADzJ83+GcZHnnuMNj+mj7++VtfakRx6aXvX2qdY++twNMf1vP/t+/T3nvWUc6r6ZS86o45jfLq78P/x8SjYqvdTIX0O+JGZGOEsYT0vpFy7KfBReyqobzYs+Xo2qKRukHQfxJuDVM28lh972Fg2tQOWXsz1Yr8l/BsPuCXn+c6xigPeHEK4AdjJ8wVBq7Y2Pz7mNUPpM7lunIeNnb+tHvfdnKt57fvAPM8j9mrty657L9BdK6Zch/nWUgNdhH8bdIMdgdzuwLyIL6Fi2clbne8CeRTWkwYShfF5V37Vpl/X6rlvbLKQRfPU1/40ff9LfTKQutExbWOSMuOWE+kq16oZsJw+ddDeODd++z79ULv/bg7XH2vtO1HwuMo4XrEfNbVpNpm8T2/RwYZd42itTK6nhfM15Q1sbG0Yi0LOz4wR515yPNqH/3nHbQnVX6ev0p3+HPbNYmZ2arbvCng7PKvA7t885IN2uJia9vbvGsrm6YcS/3lYw8f0oUzywHC0uh4mcEkT8Me5LGCZHbuvf0XzKhegUgt8Vku2bbWo+c+FRc62H92wP5qf4tzK1ifUwTmHzo8ybc5f41E7zIV6eIUO9DUf7IKbY5b1KdSznRvmseqnZA90nN64svUUeoK9hp279uf5UfU97C/zzvdpnqOHZzXQPvx7k3sd4q2BpAfW7vbb87KmvTIUZUiFwd7fdYgWD33DMoftwJz0cYXtq/6r+nKh3b++ZqWY5NqW3kszfFYwnH9trmUBy8zTMHCY1+zcDHSymo95hqtgIc2V2Uv0fFI39f6c0tfMzZv5xpnfmzk0rAcasGP1xGOZNm34L9dDdh15otbHfQ/ni9a90+8coN3PKb3aOVj+idrjmvLzcjnX1LYO5rYef86FfVzasNeZ+5nYNFj5wKFjYevhcT1GMLkqkxeH/+/TV8/gxAk/B+xP/i/2roKyEWrKzHXb4q7/ssPiAoxq36vPD+3qGvY4se6EaeWPN2Zo23Wiy4annBEzYR27BH/ey+ujLGClF3Wta3++WPZZ/UZ1zHM8/qX71HwOxjAZ9DNzSdc0B5VUrbZmHru7MSjTpg3/fghVOsvr4aG+jtKCmxdKj169ST2bP3Sx3OCm52AwLw6pO6rVXSNdT9YTPj4mzd3vt2vrwQaZfxzPu5unx2swWjfQwC4NvCb8a3NTYVvtWhhTXr4GtITw5bWv04+/vuqw7Ydua+jhLkTOnHYIRgj/LsBnAos0Ady5T4uW8C9x5r3tmi8LWGahD+edDV2JnUgXcrbXUzSGmfaToc56D8F/14JRNB5P+1paJ2XazOswqQcbQhO7zy36agJw+AvH2cAc6DwzBw9iv7DIra+ZeoKa7biaY8NPDu1786M6jzl6ujm66CQaz8N1yfW2sm8f/tWk/v2Hvuv3d7iV4fk/p4O92S3wj1sFadE0VFj2dlisIHPn6GAf3YxYQ9I3Bl+nr/4nEba9B4+rmh8cnx9Uwn+eDWawh01ZwNqy0OfD2J76kueo+Rt8f9qMfRz29LzL/Wnd3XMQnSXH5ACeZdrM6y3Wg60797p9/8hHG/5Xa5pdZ3yOgc4zc9A//pDn6rqJNTT3+zlBzcvXlx4G+9yafEifmMNHapy2+9RX+/A/T15les7wtEF4P89/yz9lEMF5qi0d0JfdxtX7c9vLpwhRmE9+FWhuTwd8728OB4Y0f2LhTHpDEA/aeUYYOSN+pk3OHdmsygKWCR5u/s5zWodrNx88Hek5uMzR6nx1+3EgMfPR1aiP4ZcIq7NvGMbKtGnD/wM9eHXrAP6KnX87L/Qa5tVrX/dqVOMWzq9Xhf/cOlfiCeaYkj+rWm+DzPOhiOeZ5wK1M67PaqCP8D9PSrszZ4J6Oiyswv38tSHzFQRlLunzNKjoRsHBU2abCi0rs1gChavVLRoPrh20teVYQeTFdQttBHVxnNPEoFzKAta8iPs7gHpuZcJ1JsxUY63bD3/B08zPxQteFvAG1VG1sfX4lWnThn9ZD359RdqQ9O3V6LcrPzdzyN6c6hrcGmTWmWBNWl3fnL/66t2uWrb5vppbtu6ljwWeUOwDuRuMbXUutXEeLNBArIGuwr82QLUT//t3/X/sVTcBscmoY+LXbKf0gu/CeDTYK/P03k+EaBfug08GzO6MqVMFi+VmYOuf3ZT6Yfvz6LFGG4+uwfueThosrK/mXRawbPCwC775NC0bRIoX/Z2sbfv60X6ytwR/xdTMWfue/xge92r+XD+vgTJt2vBvfk9s+cQ3P85aG7l1w855af2wxxQ/JsL9/LWZZVd8PsatP94nA/o6dg7meR2mJc0i5mnrETwhmJ/+HIw2DZLtv6CfxeNJbYdpjTE47Pc+2of/2UTtL/v4i3IqPOj33Y7I8p1//7zF4ENDCa8Rm6c3YZUpedeQhLxeKBazy92UpNtT5wk1PRI9BnnYpEiPl6eXR2Nz4vfLApZd6DthYsP/ibmPrLnSvpdp0wv/6OEwj1xvtNXzBLXGbltLO/Eh9HaY3ko9guPK50L78M8EWSaIDi17bgDqGS2TpXyyjMCqLGB1pj/C/+IpF/bXMm0S/tv41PzJhPvEpI4n6JuKwo24Nv1kfYDzNTVA+L/wYsmkveakPXJcywJWnYW+Wj8I/4R/38fRwwv00Jkn+Hrg+Qv0wNpbbX07SL+E/4PA9j7w1Ic5pTRQFv5hl2LHa8fqohdtZr9y+tu/p+RXUF+0k32WOpk3x84b+MI3pQHCP+GfXQE04DTQS8BKmRWvjb2Ioc2xx5/5z/ijgXoaIPwT/FzwY2LVm1hnZUnAQgO9ahdtos1etUldaPNsGiD8E/4J/2jAaYCAxSLW6yKGNtFmr9qkLrR5Ng0Q/gl+LvidTbzUW99wCVj1maLTOkzRZh2O6BGOaAANEP4J/4R/NOA0QMBiUeg1GKBNtNmrNqkLbZ5NA4R/gp8LfmcTL/XWN1wCVn2m6LQOU7RZhyN6hCMaQAOEf8I/4R8NOA0QsFgUeg0GaBNt9qpN6kKbZ9MA4Z/g54Lf2cRLvfUNl4BVnyk6rcMUbdbhiB7hiAbQAOGf8E/4RwNOAwQsFoVegwHaRJu9apO60ObZNED4J/i54Hc28VJvfcMlYNVnik7rMEWbdTiiRziiATRA+Cf8E/7RgNMAAYtFoddggDbRZq/apC60eTYNEP4Jfi74nU281FvfcAlY9Zmi0zpM0WYdjugRjmgADRD+Cf+EfzTgNEDAYlHoNRigTbTZqzapC22eTQPVw79qkH8wQANoAA2gATSABtAAGkADfWpgyvz3r8zr2ZfVAPMfBCBwXgLM4fOO3dUrR5tXH2H6BwEItCIg+Snhv9UocB0IdEJAMoROSqSMQQmgzUEHnm5DAALVCUh+SvivjpsGIdA3AckQ+q6c6q5OAG1efYTpHwQg0IqA5KeE/1ajwHUg0AkByRA6KZEyBiWAIjRotAAACs1JREFUNgcdeLoNAQhUJyD5KeG/Om4ahEDfBCRD6Ltyqrs6AbR59RGmfxCAQCsCkp8S/luNAteBQCcEJEPopETKGJQA2hx04Ok2BCBQnYDkp4T/6rhpEAJ9E5AMoe/Kqe7qBNDm1UeY/kEAAq0ISH5K+G81ClwHAp0QkAyhkxIpY1ACaHPQgafbEIBAdQKSnxL+q+OmQQj0TUAyhL4rp7qrE0CbVx9h+gcBCLQiIPkp4b/VKHAdCHRCQDKETkqkjEEJoM1BB55uQwAC1QlIfkr4r46bBiHQNwHJEPqunOquTgBtXn2E6R8EINCKgOSnhP9Wo8B1INAJAckQOimRMgYlgDYHHXi6DQEIVCcg+SnhvzpuGoRA3wQkQ+i7cqq7OgG0efURpn8QgEArApKfEv5bjQLXgUAnBCRD6KREyhiUANocdODpNgQgUJ2A5KeE/+q4aRACfROQDKHvyqnu6gTQ5tVHmP5BAAKtCEh+SvhvNQpcBwKdEJAMoZMSKWNQAmhz0IGn2xCAQHUCkp8eGv7fv92mL3/+WnUo97p/4K8/v0Tn/prePqfbmybz3u12m4r/fXv3L/f4+T9v05db7vrS6e/T/Xab7j+lY3gPAu0ISIbQrgp7JTU/7tPG2WhP5vFiBA7T5s/7dNvq+U+zNd6fWgOfbrqbBuz6Nq/BzRl3A4JCINAdAclPXxL+p8kaRo6Vev/L9PZP/P5Gg1GGn2wnbvfRz7l6Hp03v69vHAg4hbQ47GACkiEcfOmgeXWDb27WmRsBmIF/qK9Nb2OoeTA169zrw/+j9Xa/4MKNvOOus79CzoTAuAQkP20W/pVJiLvyvjHPuzRLOBDO/fw2rT5bmHfpXbDQNwH7d991HX59O7QUmuSOBjgFApUISIZQ6RIPm3HzQc9Nwv9DYIMcUFeby6aNXn+e9PDzDsFBoTyxqaXXytSafF54VA6B0xKQ/PSY8D+H7SXs36d75itAmuoc9g1hs1Oza7fEXXcOE5E5uRuQTYvAsoA8pQBVC6b4FEJOrkNAMoTnr2CDhrfjqr6Ol5tzhP/nkV+ohWJtWt0EGz35DZ7XhH87F+YBStbsfcKt3/d+1qeZNpb10Pxs19bl9WmabPv68Tbd1Hpjn7uvxMbt7xdPclNMj0e9a+yvjjMhAAHJT48J/zNzt7sXjEFkiMF702R3+62pZU3bGp063xpcHDCi8G8vZa5RuNuo2q4S2lW/MUU7Bjy+joBkCM9XZcOJr3Xzmp3TwTX8eRy8wQ8jEijWpvV835v1a77uFoLZdWQ55IBn0Vq3qnm+QXZ9iI5XFfnzY77RWX5/LDreth+vgw+/Zrun67lNOvP6UuOetjkHAhCoQUDy0wbh/226O3Obw/3KnOZuzrsGX/xf7M0E+FZmntzdmMu1Nyp6F8b1SRlyagHCFGuImTaeJyAZQtj6+3R3uvbemUOI2X2MtW4CSRz09VzxfMC15ocb9yJPRiVQrE2tm1h7uUA6Ta3Wi3DcUuE8qjnSf1yn/7P/3F4nWJ+STNSRUR325Kce8+uZqjOe/09dipMhAIFdBCQ/PS78ayNS39VXO+zGKOxHlenH+/T+865NIzSPlMmkA7Y2R/fxZv73BLbsSgTmGuBXNSyfHvjXThtfqh9Bg/wAgSYEJEOICwjmopvT3tcrVjfnmaARhRx3ndzr7gCejESgWJsZ3WgfTtyw5l4/lm00F1I1x68FP/vnC2uovakOzvV75rfjv/7M83ybgWc8cwnOhQAEniIg+ekx4V+Z0Ld3vdviB2EVpP2f7Z/ojMN4bB6rAK7at4bnoYnP896an24P4KtrrxstfGX7tQsb5jAIbCIgGUKqIR2c9E31crObOs68lgkFuWCSez1/Ad65MIFibWZ0o7V65vDv79IHfTTrR7h+RkIIjvffy8xJ/5DNz/Pr2eN1ePPFOAECENhBQPLTY8L/XGRgAtqYwo8DdbAuCfHR7mLQrgck9/pySN6wlmOiZ6ruRI3RUQU/KgOOPvItOItDIFCbgGQIz1/LBI04pOTmevCd5ucvTgsnJ1CsTb2exH6aD8hqbcj+0vlhzKLQnQrniddsrfF6pl+X1qJEW6ZrUR1V+ptjvWONrVIPjUAAAjEByU/bhf+5Kh0C3Fdz0juJsemFnxAoIys9L0axx5jy14tbF39WxiwZt3gyb0KgHgHJEJ6/igkawf9fY/4dgfgTPn2tbGB5vhJaOB+BYm1q3cx/0Wbupllb8mvDw/Av6XQXyih0p7See+3zfbp/jm5u5vr8G2vVZzevUm3puk0d/nm7uhOdpHmvPmVR14rqjs7jRwhAoA0ByU+bh3+9e6HC/7c3/X/sVd//j01pHf4XUGnDMe+7tt3NRfp7/84sl2bFZ1I94onemzXa8JrjKQR2E5AMYXej7kQbeMyj/f2e7JzLBhbXIE8GIlCsTasb/Wh9Ph38FT69NqyCagS2l/Bvf0cutVkU9DdaOy2TqFvqR3NjpDhVDOaaV8hcXydVd6ImXoIABI4lIPnpMeF/NlFrNH4oT4UA/b5nGDYo++fZELF+XMzMnpfHuWfnX7X25G5GwiTzNfIOBI4lIBnC81e24f/5lmhhPALF2hSC7njUXtfjcM1l7r9uJLgyBNYEJD89Jvyvazj/K3qxWW40yjuEIZaz4sgWBCRDeP766P15huO2UKxNwn8nIrHz3WysPfxqVSdVUwYERiAg+SnhfwQF0EcIeAQkQ/AO2/nUhoGdp3Pa0ASKtUn4H1ondB4CEHhMQPJTwv9jfhwBgUsRkAzhUh2lM6cj0Is2s185/fyfaf3V0/AXj88Gffl9APu7E/Pj//zf9L/J35/b8wn42ahQLwTOT0DyU8L/+ceXHkBgEwHJEDY1xMEQqEwAbVYGSnMQgMCwBCQ/JfwPKws6PioByRBGZUK/+yCANvsYB6qAAATOT0DyU8L/+ceXHkBgEwHJEDY1xMEQqEwAbVYGSnMQgMCwBCQ/JfwPKws6PioByRBGZUK/+yCANvsYB6qAAATOT0DyU8L/+ceXHkBgEwHJEDY1xMEQqEwAbVYGSnMQgMCwBCQ/JfwPKws6PioByRBGZUK/+yCANvsYB6qAAATOT0DyU8L/+ceXHkBgEwHJEDY1xMEQqEwAbVYGSnMQgMCwBCQ/JfwPKws6PioByRBGZUK/+yCANvsYB6qAAATOT0DyU8L/+ceXHkBgEwHJEDY1xMEQqEwAbVYGSnMQgMCwBCQ/JfwPKws6PioByRBGZUK/+yCANvsYB6qAAATOT0DyU8L/+ceXHkBgEwHJEDY1xMEQqEwAbVYGSnMQgMCwBCQ/JfwPKws6PioByRBGZUK/+yCANvsYB6qAAATOT0DyU8L/+ceXHkBgEwHJEDY1xMEQqEwAbVYGSnMQgMCwBCQ/3RX+VYP8gwEaQANoAA2gATSABtAAGuhTA7k7n83hP9cQr0MAAhCAAAQgAAEIQAACfRMg/Pc9PlQHAQhAAAIQgAAEIACBagQI/9VQ0hAEIAABCEAAAhCAAAT6JkD473t8qA4CEIAABCAAAQhAAALVCBD+q6GkIQhAAAIQgAAEIAABCPRNgPDf9/hQHQQgAAEIQAACEIAABKoRIPxXQ0lDEIAABCAAAQhAAAIQ6JsA4b/v8aE6CEAAAhCAAAQgAAEIVCNA+K+GkoYgAAEIQAACEIAABCDQN4H/By2I2HayhfuGAAAAAElFTkSuQmCC"
    }
   },
   "cell_type": "markdown",
   "id": "959409de-e6cb-44eb-96cd-27528dcaf6c3",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "![image.png](attachment:3ddd1a43-e0e6-4cd0-bc4b-ac50f46ab3c9.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7066707-96ab-4751-b7eb-05c50e897dc0",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "### \n",
    "Python中的比较运算符重载"
   ]
  },
  {
   "attachments": {
    "51ce0916-a604-4ec5-8692-15eb25e040e3.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "3c9312d8-5df4-45f8-9092-1e1456748700",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "![image.png](attachment:51ce0916-a604-4ec5-8692-15eb25e040e3.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5de56920-1f4e-45d4-bb57-b11bc2403fbe",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    ">> 练一练：假设，我们想在Point类中实现小于运算符（<） ，让我们从原点比较这些点的大小，并为此目的返回结果。如何实现？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "4d77c4ae-ba34-4071-ba94-097dc8dc6b4b",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "class Point:\n",
    "    def __init__(self, x = 0, y = 0):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "    \n",
    "    def __str__(self):\n",
    "        return \"({0},{1})\".format(self.x,self.y)\n",
    "    \n",
    "    def __lt__(self,other):\n",
    "        self_mag = (self.x ** 2) + (self.y ** 2)\n",
    "        other_mag = (other.x ** 2) + (other.y ** 2)\n",
    "        return self_mag < other_mag\n",
    "\n",
    "print(Point(1,1) < Point(-2,-3))\n",
    "print(Point(1,1) < Point(0.5,-0.2))\n",
    "print(Point(1,1) < Point(1,1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97b7b465-4e8a-443b-8c13-0a3e9f87b9ec",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad80764f-ff57-4dd8-ab0a-b8d87d455113",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "### 打印对象\n",
    "\n",
    "上面我们通过`__init__`方法在创建对象时为对象绑定了属性并赋予了初始值。如果我们在打印对象的时候不希望看到对象的地址而是看到我们自定义的信息，可以通过在类中放置`__repr__`魔术方法来做到，该方法返回的字符串就是用`print`函数打印对象的时候会显示的内容。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "65254631-d557-40fc-b1b7-b07c9e47ea36",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "骆昊: 40\n",
      "[骆昊: 40, 李元芳: 36, 王大锤: 25]\n"
     ]
    }
   ],
   "source": [
    "class Student:\n",
    "    \"\"\"学生\"\"\"\n",
    "\n",
    "    def __init__(self, name, age):##定义属性\n",
    "        \"\"\"初始化方法\"\"\"\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "\n",
    "    def study(self, course_name):\n",
    "        \"\"\"学习\"\"\"\n",
    "        print(f'{self.name}正在学习{course_name}.')\n",
    "\n",
    "    def play(self):\n",
    "        \"\"\"玩耍\"\"\"\n",
    "        print(f'{self.name}正在玩游戏.')\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return f'{self.name}: {self.age}'\n",
    "\n",
    "\n",
    "stu1 = Student('骆昊', 40)\n",
    "print(stu1)        # 骆昊: 40\n",
    "students = [stu1, Student('李元芳', 36), Student('王大锤', 25)]\n",
    "print(students)    # [骆昊: 40, 李元芳: 36, 王大锤: 25]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2dc37964-37ff-43a3-8470-d0aad12ca573",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "在很多场景下，面向对象编程其实就是一个三步走的问题。第一步定义类，第二步创建对象，第三步给对象发消息。当然，有的时候我们是不需要第一步的，因为我们想用的类可能已经存在了。之前我们说过，Python内置的`list`、`set`、`dict`其实都不是函数而是类，如果要创建列表、集合、字典对象，我们就不用自定义类了。当然，有的类并不是Python标准库中直接提供的，它可能来自于第三方的代码，如何安装和使用三方代码在后续课程中会进行讨论。在某些特殊的场景中，我们会用到名为“内置对象”的对象，所谓“内置对象”就是说上面三步走的第一步和第二步都不需要了，因为类已经存在而且对象已然创建过了，直接向对象发消息就可以了，这也就是我们常说的“开箱即用”。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5325b3e8-0a83-4f29-a0f2-7a42b310c185",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "### 经典案例"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ef0ca23-d6cc-4598-8dee-d679873e4d55",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "#### 案例1：定义一个类描述数字时钟。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "1ce6c354-20b2-461f-8959-885641468468",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23:59:58\n",
      "23:59:59\n",
      "00:00:00\n",
      "00:00:01\n",
      "00:00:02\n",
      "00:00:03\n",
      "00:00:04\n",
      "00:00:05\n",
      "00:00:06\n",
      "00:00:07\n",
      "00:00:08\n",
      "00:00:09\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m----------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0mTraceback (most recent call last)",
      "Cell \u001b[1;32mIn[18], line 40\u001b[0m\n\u001b[0;32m     38\u001b[0m \u001b[38;5;28mprint\u001b[39m(clock\u001b[38;5;241m.\u001b[39mshow())\n\u001b[0;32m     39\u001b[0m \u001b[38;5;66;03m# 休眠1秒钟\u001b[39;00m\n\u001b[1;32m---> 40\u001b[0m \u001b[43mtime\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msleep\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[0;32m     41\u001b[0m \u001b[38;5;66;03m# 给时钟对象发消息使其走字\u001b[39;00m\n\u001b[0;32m     42\u001b[0m clock\u001b[38;5;241m.\u001b[39mrun()\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "# 定义数字时钟类\n",
    "class Clock(object):\n",
    "    \"\"\"数字时钟\"\"\"\n",
    "\n",
    "    def __init__(self, hour=0, minute=0, second=0):\n",
    "        \"\"\"初始化方法\n",
    "        :param hour: 时\n",
    "        :param minute: 分\n",
    "        :param second: 秒\n",
    "        \"\"\"\n",
    "        self.hour = hour\n",
    "        self.min = minute\n",
    "        self.sec = second\n",
    "\n",
    "    def run(self):\n",
    "        \"\"\"走字\"\"\"\n",
    "        self.sec += 1\n",
    "        if self.sec == 60:\n",
    "            self.sec = 0\n",
    "            self.min += 1\n",
    "            if self.min == 60:\n",
    "                self.min = 0\n",
    "                self.hour += 1\n",
    "                if self.hour == 24:\n",
    "                    self.hour = 0\n",
    "\n",
    "    def show(self):\n",
    "        \"\"\"显示时间\"\"\"\n",
    "        return f'{self.hour:0>2d}:{self.min:0>2d}:{self.sec:0>2d}'\n",
    "\n",
    "\n",
    "# 创建时钟对象\n",
    "clock = Clock(23, 59, 58)\n",
    "while True:\n",
    "    # 给时钟对象发消息读取时间\n",
    "    print(clock.show())\n",
    "    # 休眠1秒钟\n",
    "    time.sleep(1)\n",
    "    # 给时钟对象发消息使其走字\n",
    "    clock.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df5052ea-3a45-4950-830f-542c00bebc7b",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "案例2：定义一个类描述平面上的点，要求提供计算到另一个点距离的方法。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "1fdb92fc-9e49-4e1e-b2c3-8609a162d073",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 5) (6, 9)\n",
      "5.0\n"
     ]
    }
   ],
   "source": [
    "class Point(object):\n",
    "    \"\"\"屏面上的点\"\"\"\n",
    "\n",
    "    def __init__(self, x=0, y=0):\n",
    "        \"\"\"初始化方法\n",
    "        :param x: 横坐标\n",
    "        :param y: 纵坐标\n",
    "        \"\"\"\n",
    "        self.x, self.y = x, y\n",
    "\n",
    "    def distance_to(self, other):\n",
    "        \"\"\"计算与另一个点的距离\n",
    "        :param other: 另一个点\n",
    "        \"\"\"\n",
    "        dx = self.x - other.x\n",
    "        dy = self.y - other.y\n",
    "        return (dx * dx + dy * dy) ** 0.5\n",
    "\n",
    "    def __str__(self):\n",
    "        return f'({self.x}, {self.y})'\n",
    "\n",
    "\n",
    "p1 = Point(3, 5)\n",
    "p2 = Point(6, 9)\n",
    "print(p1, p2)\n",
    "print(p1.distance_to(p2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4cd3e9b0-f6ec-48df-b97b-f6d5fc5c687e",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "skip"
    },
    "tags": []
   },
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0efd8e84-b25b-47b2-b937-459e17874801",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "### 可见性\n",
    "\n",
    "对象的属性通常会被设置为私有（private）或受保护（protected）的成员，简单的说就是不允许直接访问这些属性；对象的方法通常都是公开的（public），因为公开的方法是对象能够接受的消息，也是对象暴露给外界的调用接口，这就是所谓的访问可见性。在Python中，可以通过给对象属性名添加前缀下划线的方式来说明属性的访问可见性，例如，可以用`__name`表示一个私有属性，`_name`表示一个受保护属性，代码如下所示。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "f504403c-34ec-4aa1-9ddf-72fb7fa81133",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "王大锤正在学习Python程序设计.\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'Student' object has no attribute '__name'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m----------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0mTraceback (most recent call last)",
      "Cell \u001b[1;32mIn[22], line 13\u001b[0m\n\u001b[0;32m     11\u001b[0m stu \u001b[38;5;241m=\u001b[39m Student(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m王大锤\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;241m20\u001b[39m)\n\u001b[0;32m     12\u001b[0m stu\u001b[38;5;241m.\u001b[39mstudy(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mPython程序设计\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m---> 13\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mstu\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m__name\u001b[49m)\n",
      "\u001b[1;31mAttributeError\u001b[0m: 'Student' object has no attribute '__name'"
     ]
    }
   ],
   "source": [
    "class Student:\n",
    "\n",
    "    def __init__(self, name, age):\n",
    "        self.__name = name\n",
    "        self.__age = age\n",
    "\n",
    "    def study(self, course_name):\n",
    "        print(f'{self.__name}正在学习{course_name}.')\n",
    "\n",
    "\n",
    "stu = Student('王大锤', 20)\n",
    "stu.study('Python程序设计')\n",
    "print(stu.__name)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "443ba0fb-853a-4ca6-9205-d58cece34e38",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "上面代码的最后一行会引发`AttributeError`（属性错误）异常，异常消息为：`'Student' object has no attribute '__name'`。由此可见，以`__`开头的属性`__name`是私有的，在类的外面无法直接访问，但是类里面的`study`方法中可以通过`self.__name`访问该属性。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fedcd2ee-233e-415c-b23c-0e6523ce2f2b",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "skip"
    },
    "tags": []
   },
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78b5fecd-b3d1-4804-8ca6-d87df78a37ac",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "**需要注意**：Python并没有从语法上严格保证私有属性的私密性，它只是给私有的属性和方法换了一个名字来阻挠对它们的访问，事实上如果你知道更换名字的规则仍然可以访问到它们，我们可以对上面的代码稍作修改就可以访问到私有的属性。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "e85c8f88-bcf6-4db4-b984-418285cfaa5d",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "王大锤正在学习Python程序设计.\n",
      "王大锤 20\n"
     ]
    }
   ],
   "source": [
    "class Student:\n",
    "\n",
    "    def __init__(self, name, age):\n",
    "        self.__name = name\n",
    "        self.__age = age\n",
    "\n",
    "    def study(self, course_name):\n",
    "        print(f'{self.__name}正在学习{course_name}.')\n",
    "\n",
    "stu = Student('王大锤', 20)\n",
    "stu.study('Python程序设计')\n",
    "print(stu._Student__name, stu._Student__age)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb376a6a-5791-4673-8b15-af2bd418ea4f",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "skip"
    },
    "tags": []
   },
   "source": [
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24452904-38d8-4fc0-adb8-48a078dc30c4",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "### 动态属性\n",
    "\n",
    "我们可以动态为对象添加属性，这是Python作为动态类型语言的一项特权。需要提醒大家的是，对象的方法其实本质上也是对象的属性，如果给对象发送一个无法接收的消息，引发的异常仍然是`AttributeError`。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "013635c0-baf9-43e6-903b-957bf4d0fb52",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "男\n"
     ]
    }
   ],
   "source": [
    "class Student:\n",
    "\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "\n",
    "\n",
    "stu = Student('王大锤', 20)\n",
    "# 为Student对象动态添加sex属性\n",
    "stu.sex = '男'\n",
    "print(stu.sex)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91aa484d-71af-4c1b-a3b5-6fded3aad229",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "\n",
    "\n",
    "如果不希望在使用对象时动态的为对象添加属性，可以使用Python的`__slots__`魔法。对于`Student`类来说，可以在类中指定`__slots__ = ('name', 'age')`，这样`Student`类的对象只能有`name`和`age`属性，如果想动态添加其他属性将会引发异常，代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "d50ed710-0cf3-4fc3-9ffb-34ea66618453",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'Student' object has no attribute 'sex'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m----------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0mTraceback (most recent call last)",
      "Cell \u001b[1;32mIn[58], line 11\u001b[0m\n\u001b[0;32m      9\u001b[0m stu \u001b[38;5;241m=\u001b[39m Student(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m王大锤\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;241m20\u001b[39m)\n\u001b[0;32m     10\u001b[0m \u001b[38;5;66;03m# AttributeError: 'Student' object has no attribute 'sex'\u001b[39;00m\n\u001b[1;32m---> 11\u001b[0m \u001b[43mstu\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msex\u001b[49m \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m男\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[0;32m     12\u001b[0m \u001b[38;5;28mprint\u001b[39m(stu\u001b[38;5;241m.\u001b[39msex)\n",
      "\u001b[1;31mAttributeError\u001b[0m: 'Student' object has no attribute 'sex'"
     ]
    }
   ],
   "source": [
    "class Student:\n",
    "    __slots__ = ('name', 'age')\n",
    "\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "\n",
    "\n",
    "stu = Student('王大锤', 20)\n",
    "# AttributeError: 'Student' object has no attribute 'sex'\n",
    "stu.sex = '男'\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5725204-31f2-49f5-953f-3dc3a2f5679e",
   "metadata": {
    "editable": true,
    "raw_mimetype": "",
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "### 简单的总结\n",
    "\n",
    "- 面向对象编程是一种非常流行的编程范式，除此之外还有**指令式编程**、**函数式编程**等编程范式。由于现实世界是由对象构成的，而对象是可以接收消息的实体，所以**面向对象编程更符合人类正常的思维习惯**。类是抽象的，对象是具体的，有了类就能创建对象，有了对象就可以接收消息，这就是面向对象编程的基础。定义类的过程是一个抽象的过程，找到对象公共的属性属于数据抽象，找到对象公共的方法属于行为抽象。抽象的过程是一个仁者见仁智者见智的过程，对同一类对象进行抽象可能会得到不同的结果。\n",
    "- Python是动态语言，Python中的对象可以动态的添加属性。在面向对象的世界中，**一切皆为对象**，我们定义的类也是对象，所以**类也可以接收消息**，对应的方法是类方法或静态方法。通过继承，我们**可以从已有的类创建新类**，实现对已有类代码的复用。\n",
    "> **说明：** 本节课的插图来自于 Grady Booc 等撰写的《面向对象分析与设计》一书，该书是讲解面向对象编程的经典著作，有兴趣的读者可以购买和阅读这本书来了解更多的面向对象的相关知识。"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.11"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
